[Swift]LeetCode883. 三维形体投影面积 | Projection Area of 3D Shapes

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

On a N * N grid, we place some 1 * 1 * 1 cubes that are axis-aligned with the x, y, and z axes.

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

Now we view the projection of these cubes onto the xy, yz, and zx planes.

A projection is like a shadow, that maps our 3 dimensional figure to a 2 dimensional plane. 

Here, we are viewing the "shadow" when looking at the cubes from the top, the front, and the side.

Return the total area of all three projections.

Example 1:

Input: [[2]]
Output: 5

Example 2:

Input: [[1,2],[3,4]]
Output: 17
Explanation: 
Here are the three projections ("shadows") of the shape made with each axis-aligned plane.

Example 3:

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

Example 4:

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

Example 5:

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

Note:

• 1 <= grid.length = grid[0].length <= 50
• 0 <= grid[i][j] <= 50

---

在 N * N 的网格中，我们放置了一些与 x，y，z 三轴对齐的 1 * 1 * 1 立方体。

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

现在，我们查看这些立方体在 xy、yz 和 zx 平面上的投影。

投影就像影子，将三维形体映射到一个二维平面上。

在这里，从顶部、前面和侧面看立方体时，我们会看到“影子”。

返回所有三个投影的总面积。 

示例 1：

输入：[[2]]
输出：5

示例 2：

输入：[[1,2],[3,4]]
输出：17
解释：
这里有该形体在三个轴对齐平面上的三个投影(“阴影部分”)。

示例 3：

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

示例 4：

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

示例 5：

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

提示：

• 1 <= grid.length = grid[0].length <= 50
• 0 <= grid[i][j] <= 50


---

48ms

class Solution {
    func projectionArea(_ grid: [[Int]]) -> Int {
        var xy = 0, xz = 0, yz = [Int]()
        for row in grid {
            var z = 0
            for cell in 0..<row.count {
                if row[cell] > 0 {
                    xy += 1
                }
                z = row[cell] > z ? row[cell] : z
                if cell < yz.count {
                    yz[cell] = row[cell] > yz[cell] ? row[cell] : yz[cell]
                } else {
                    yz.append(row[cell])
                }
                
            }
            xz += z
        }
        return xy + xz + yz.reduce(0, +)
    }
}

---

Runtime: 52 ms

Memory Usage: 19.3 MB

class Solution {
    func projectionArea(_ grid: [[Int]]) -> Int {
        var z:Int = 0
        var x:Int = 0
        var y:Int = 0
        for i in 0..<grid.count
        {
            var mx:Int = 0
            var my:Int = 0
            for j in 0..<grid.count
            {
                mx = max(mx, grid[j][i])
                my = max(my, grid[i][j])
                if grid[i][j] > 0
                {
                    z += 1
                }
            }
            x += mx
            y += my
        }
        return x + y + z
    }
}

---

52ms

class Solution {
    func projectionArea(_ grid: [[Int]]) -> Int {
        guard grid.count > 0, grid[0].count > 0 else {
            return 0
        }
        var sumx = 0
        var sumy = 0
        var x = 0
        var y = 0
        var z = 0
        for i in 0..<grid.count {
            x = 0
            for j in 0..<grid[0].count {
                if grid[i][j] > 0 {
                    z += 1
                    x = max(x,grid[i][j])
                }
            }
            sumx += x
        }
        for i in 0..<grid[0].count {
            y = 0
            for j in 0..<grid.count {
                if grid[j][i] > 0 {
                    y = max(y,grid[j][i])
                }
            }
            sumy += y
        }
        return sumx+sumy+z
    }
}

---

56ms

class Solution {
    func projectionArea(_ grid: [[Int]]) -> Int {
        let topShadow = grid.map { r in r.filter { $0 != 0 }.count }.reduce(0, +)
        let xShadow = grid.reduce(0) { return $0 + ($1.max() ?? 0) }
        let yShadow = Array(0 ..< grid[0].count).map { c in grid.map {$0[c] }.max() ?? 0 }.reduce(0, +)
        return topShadow + xShadow + yShadow
    }
}

---

60ms

class Solution {
    func projectionArea(_ grid: [[Int]]) -> Int {        
        var topCounter = 0
        var leftCounter = 0
        var rightCounter = 0
        for i in 0..<grid.count {
            var maxLine = 0
            for j in 0..<grid[0].count {
                if grid[i][j] != 0 {
                    topCounter += 1
                }
                maxLine = max(maxLine, grid[i][j])
            }
            leftCounter += maxLine
        }
        
        for j in 0..<grid[0].count {
            var maxCol = 0
            for i in 0..<grid.count {
                maxCol = max(maxCol, grid[i][j])
            }
            rightCounter += maxCol
        }
        return topCounter + rightCounter + leftCounter
    }
}

---

64ms

class Solution {
    func projectionArea(_ grid: [[Int]]) -> Int {
        var total = 0
        
        for i in 0..<grid.count {
            var maxValue = 0
            for j in 0..<grid[0].count {
                if grid[i][j] != 0 {
                    total += 1
                }
                maxValue = max(maxValue, grid[i][j])
            }
            total += maxValue
        }
        
        for j in 0..<grid[0].count {
            var maxValue = 0
            for i in 0..<grid.count {
                maxValue = max(maxValue, grid[i][j])
            }
            total += maxValue
        }
        
        return total
    }
}

---

100ms

class Solution {
    func projectionArea(_ grid: [[Int]]) -> Int {
        //每个子数组的 count 相加 (要剔除0)
        var x = 0
        //每个 index 的最大值相加
        var y = 0
        //每个子数组的最大值相加
        var z = 0
        //用于统计每个 index 的最大值 key 为 index
        var dictY: [Int: Int] = [:]
        grid.forEach { (sun) in
            if let max = sun.max() {
                z += max
            }
            sun.enumerated().forEach({ (index, value) in
                if value != 0 {
                    x += 1
                }
                if let tempY = dictY[index] {
                    if tempY < value {
                        //如果存在并小于，更新
                        dictY.updateValue(value, forKey: index)
                    }
                }else {
                    //不存在直接更新
                    dictY.updateValue(value, forKey: index)
                }
            })
        }
        dictY.values.forEach{y += $0}
        return x + y + z
    }
}