[Swift]LeetCode223. 矩形面积 | Rectangle Area

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10203093.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Find the total area covered by two rectilinear rectangles in a 2D plane.

Each rectangle is defined by its bottom left corner and top right corner as shown in the figure.

Example:

Input: A = -3, B = 0, C = 3, D = 4, E = 0, F = -1, G = 9, H = 2
Output: 45

Note:

Assume that the total area is never beyond the maximum possible value of int.

---

在二维平面上计算出两个由直线构成的矩形重叠后形成的总面积。

每个矩形由其左下顶点和右上顶点坐标表示，如图所示。

示例:

输入: -3, 0, 3, 4, 0, -1, 9, 2
输出: 45

说明: 假设矩形面积不会超出 int 的范围。

---

32ms

class Solution {
    struct Rectangle {
        var xl: Int
        var yl: Int
        var xr: Int
        var yr: Int

        static var zero: Rectangle {
            return Rectangle(xl: 0, yl: 0, xr: 0, yr: 0)
        }

        var area: Int {
            return (xr - xl) * (yr - yl)
        }
    }

    private func computeIntersetion(r1: Rectangle, r2: Rectangle) -> Rectangle {
        if r2.xr < r1.xl || r2.xl > r1.xr {
            // No intersection on the X axis
            return Rectangle.zero
        }

        if r2.yr < r1.yl || r2.yl > r1.yr {
            // No intersection on the Y axis
            return Rectangle.zero
        }

        let intersection = Rectangle(xl: max(r1.xl, r2.xl), yl: max(r1.yl, r2.yl),
                                     xr: min(r1.xr, r2.xr), yr: min(r1.yr, r2.yr))

        return intersection
    }

    func computeArea(_ A: Int, _ B: Int, _ C: Int, _ D: Int, _ E: Int, _ F: Int, _ G: Int, _ H: Int) -> Int {
        let r1 = Rectangle(xl: A, yl: B, xr: C, yr: D)
        let r2 = Rectangle(xl: E, yl: F, xr: G, yr: H)
        let intersection = computeIntersetion(r1: r1, r2: r2)

        return r1.area + r2.area - intersection.area
    }
}

---

36ms

class Solution {
    func computeArea(_ A: Int, _ B: Int, _ C: Int, _ D: Int, _ E: Int, _ F: Int, _ G: Int, _ H: Int) -> Int {

        var sum = (C-A)*(D-B)+(G-E)*(H-F)
        if E>=C || H<=B || F>=D || G<=A { return sum }
        return sum - (min(G, C) - max(A, E)) * (min(D, H) - max(B, F))
    }
}

---

40ms

class Solution {
    func computeArea(_ A: Int, _ B: Int, _ C: Int, _ D: Int, _ E: Int, _ F: Int, _ G: Int, _ H: Int) -> Int {

        let area1 = (C - A) * (D - B)
        let area2 = (G - E) * (H - F)
        let sum = area1 + area2
        
        if A >= G || C <= E || B >= H || D <= F {
            return sum
        } else {
            let x = [A,C,E,G].sorted(by: < )
            let w = x[2] - x[1]
            let y = [B,D,F,H].sorted(by: < )
            let h = y[2] - y[1]
            
            return sum - (w*h)
        }

    }
}

---

40ms

class Solution {
    func computeArea(_ A: Int, _ B: Int, _ C: Int, _ D: Int, _ E: Int, _ F: Int, _ G: Int, _ H: Int) -> Int {
        let area1 = abs(A - C) * abs(B - D)
        let area2 = abs(E - G) * abs(F - H)
        let area3 = abs(min(C, G) - max(A, E)) * abs(min(D, H) - max(B, F))
        if ((E <= A && A <= G) || (E <= C && C <= G) || (A <= E && E <= C) || (A <= G && G <= C))
        && ((F <= B && B <= H) || (F <= D && D <= H) || (B <= F && F <= D) || (B <= H && H <= D)) {  
            return area1 + area2 - area3
        } else {
            return area1 + area2
        }
    }
}

---

68ms

class Solution {
    func computeArea(_ A: Int, _ B: Int, _ C: Int, _ D: Int, _ E: Int, _ F: Int, _ G: Int, _ H: Int) -> Int {
         if A > C || B > D || E > G || F > H {
            return 0
        }
        let area = (C - A) * (D - B) + (G - E) * (H - F)
        if max(A, E) > min(C, G) || max(B, F) > min(D, H){
            return area
        }
        return area - (min(C, G) - max(A, E)) * (min(D, H) - max(B, F))
    }
}

---

92ms

class Solution {
    func computeArea(_ A: Int, _ B: Int, _ C: Int, _ D: Int, _ E: Int, _ F: Int, _ G: Int, _ H: Int) -> Int {
        let x = overlap(A, C, E, G)
        let y = overlap(B, D, F, H)
        let first = (D-B)*(C-A)
        let sec = (G-E)*(H-F)
        return first + sec - x*y
    }
    
    func overlap(_ A: Int,_ B: Int,_ C: Int,_ D: Int) -> Int {
        if A == B || C == D {
            return 0
        }
        if (A <= C && B >= D){
            return D-C
        }
        if (C<=A && D>=B) {
            return B-A
        }
        return (B-A) + (D-C) - max(D-A, B-C) > 0 ? (B-A) + (D-C) - max(D-A, B-C) : 0
    }
}