[Swift]LeetCode892. 三维形体的表面积 | Surface Area of 3D Shapes

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

On a N * N grid, we place some 1 * 1 * 1 cubes.

Each value v = grid[i][j] represents a tower of v cubes placed on top of grid cell (i, j).

Return the total surface area of the resulting shapes.

Example 1:

Input: [[2]]
Output: 10

Example 2:

Input: [[1,2],[3,4]]
Output: 34

Example 3:

Input: [[1,0],[0,2]]
Output: 16

Example 4:

Input: [[1,1,1],[1,0,1],[1,1,1]]
Output: 32

Example 5:

Input: [[2,2,2],[2,1,2],[2,2,2]]
Output: 46 

Note:

• 1 <= N <= 50
• 0 <= grid[i][j] <= 50

---

在 N * N 的网格上，我们放置一些 1 * 1 * 1  的立方体。

每个值 v = grid[i][j] 表示 v 个正方体叠放在单元格 (i, j) 上。

返回结果形体的总表面积。 

示例 1：

输入：[[2]]
输出：10

示例 2：

输入：[[1,2],[3,4]]
输出：34

示例 3：

输入：[[1,0],[0,2]]
输出：16

示例 4：

输入：[[1,1,1],[1,0,1],[1,1,1]]
输出：32

示例 5：

输入：[[2,2,2],[2,1,2],[2,2,2]]
输出：46 

提示：

• 1 <= N <= 50
• 0 <= grid[i][j] <= 50

---

Runtime: 52 ms

Memory Usage: 19.1 MB

class Solution {
    func surfaceArea(_ grid: [[Int]]) -> Int {
        var res:Int = 0
        var n:Int = grid.count
        for i in 0..<n
        {
            for j in 0..<n
            {
                if grid[i][j] > 0
                {
                    res += grid[i][j] * 4 + 2
                }
                if i > 0
                {
                    res -= min(grid[i][j], grid[i - 1][j]) * 2
                }
                if j > 0
                {
                    res -= min(grid[i][j], grid[i][j - 1]) * 2
                }
            }
        }
        return res
    }
}

---

60ms

class Solution {
    func surfaceArea(_ grid: [[Int]]) -> Int {
        let n = grid.count
        var result = 0
        
        for i in 0..<n {
            for j in 0..<n {
                let g = grid[i][j]
                if g == 0 {
                    continue
                }        
                result += 2
                
                if i > 0 {
                    result += max(0, g-grid[i-1][j])
                } else {
                    result += g
                }
                
                if j > 0 {
                    result += max(0, g-grid[i][j-1])
                } else {
                    result += g
                }
                
                if i+1 < n {
                    result += max(0, g-grid[i+1][j])
                } else {
                    result += g
                }
                
                if j+1 < n {
                    result += max(0, g-grid[i][j+1])
                } else {
                    result += g
                }
            }
        }
        return result
    }
}

---

88ms

class Solution {
    func surfaceArea(_ grid: [[Int]]) -> Int {
        
        var sum=0,a=0,b=0,c=0,d=0
        for (i,item) in grid.enumerated() {
            for (j,subitem) in item.enumerated() {
                if subitem > 0 {
                    sum += 2
                    a = j < grid[i].count-1 ? grid[i][j+1] : 0
                    b = j > 0 ? grid[i][j-1] : 0
                    c = i > 0 ? grid[i-1][j] : 0
                    d = i < grid.count-1 ? grid[i+1][j] : 0
                    sum += (max(subitem-a, 0)+max(subitem-b, 0)+max(subitem-c, 0)+max(subitem-d, 0))
                }
            }
        }
        return sum
    }
}

---

100ms

class Solution {
    func surfaceArea(_ grid: [[Int]]) -> Int {
       func getSingleFaceArea(_ arr: [Int]) -> Int {
            var result = 0
            //上一个 x
            var lastX = 0
            arr.forEach { (x) in
                //单独一堆的面积
                let temp = (x == 0 ? 0 : (6 * x) - ((x - 1) * 2))
                result += temp
                let minX = lastX <= x ? lastX : x
                //减去两堆拼起来以后，遮住的面积
                result -= 2 * minX
                lastX = x
            }
            return result
        }
        
        var result = 0
        var lastArr: [Int] = []
        for i in (0..<grid.count) {
            let current = grid[i]
            result += getSingleFaceArea(current)
            if i != 0 {
                for i in (0..<current.count) {
                    //减去两排拼起来以后，遮住的面积
                    let x = lastArr[i] <= current[i] ? lastArr[i] : current[i]
                    result -= x * 2
                }
            }
            lastArr = current
        }
        return result
    }
}