[Swift]LeetCode807. 保持城市天际线 | Max Increase to Keep City Skyline

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

In a 2 dimensional array grid, each value grid[i][j]represents the height of a building located there. We are allowed to increase the height of any number of buildings, by any amount (the amounts can be different for different buildings). Height 0 is considered to be a building as well. 

At the end, the "skyline" when viewed from all four directions of the grid, i.e. top, bottom, left, and right, must be the same as the skyline of the original grid. A city's skyline is the outer contour of the rectangles formed by all the buildings when viewed from a distance. See the following example.

What is the maximum total sum that the height of the buildings can be increased?

Example:
Input: grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
Output: 35
Explanation: 
The grid is:
[ [3, 0, 8, 4], 
  [2, 4, 5, 7],
  [9, 2, 6, 3],
  [0, 3, 1, 0] ]

The skyline viewed from top or bottom is: [9, 4, 8, 7]
The skyline viewed from left or right is: [8, 7, 9, 3]

The grid after increasing the height of buildings without affecting skylines is:

gridNew = [ [8, 4, 8, 7],
            [7, 4, 7, 7],
            [9, 4, 8, 7],
            [3, 3, 3, 3] ]

Notes:

• 1 < grid.length = grid[0].length <= 50.
• All heights grid[i][j] are in the range [0, 100].
• All buildings in grid[i][j] occupy the entire grid cell: that is, they are a 1 x 1 x grid[i][j]rectangular prism.

---

在二维数组grid中，grid[i][j]代表位于某处的建筑物的高度。 我们被允许增加任何数量（不同建筑物的数量可能不同）的建筑物的高度。 高度 0 也被认为是建筑物。

最后，从新数组的所有四个方向（即顶部，底部，左侧和右侧）观看的“天际线”必须与原始数组的天际线相同。 城市的天际线是从远处观看时，由所有建筑物形成的矩形的外部轮廓。 请看下面的例子。

建筑物高度可以增加的最大总和是多少？

例子：
输入： grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
输出： 35
解释： 
The grid is:
[ [3, 0, 8, 4], 
  [2, 4, 5, 7],
  [9, 2, 6, 3],
  [0, 3, 1, 0] ]

从数组竖直方向（即顶部，底部）看“天际线”是：[9, 4, 8, 7]
从水平水平方向（即左侧，右侧）看“天际线”是：[8, 7, 9, 3]

在不影响天际线的情况下对建筑物进行增高后，新数组如下：

gridNew = [ [8, 4, 8, 7],
            [7, 4, 7, 7],
            [9, 4, 8, 7],
            [3, 3, 3, 3] ]

说明:

• 1 < grid.length = grid[0].length <= 50。
•  grid[i][j] 的高度范围是： [0, 100]。
• 一座建筑物占据一个grid[i][j]：换言之，它们是 1 x 1 x grid[i][j] 的长方体。

---

Runtime: 44 ms

Memory Usage: 18.4 MB

class Solution {
    func maxIncreaseKeepingSkyline(_ grid: [[Int]]) -> Int {        
        if grid.count <= 1 {
            return 0
        }
        
        let count = grid.count
        
        var hHeight:[Int] = Array(repeating: 0 , count: count)
        var vHeight:[Int] = Array(repeating: 0 , count: count)        
        
        var height : Int = 0
        
        for hIdx in 0..<count{
            for vIdx in 0..<count {
                height = grid[hIdx][vIdx]
                if height > hHeight[hIdx] {
                    hHeight[hIdx] = height
                }
                if height > vHeight[vIdx] {
                    vHeight[vIdx] = height
                }
            }
        }        

        var gridOffsetCount:Int = 0
        var maxGrid : Int = 0
        for vIdx in 0..<count{
            for hIdx in 0..<count {
                maxGrid = min(vHeight[vIdx] , hHeight[hIdx])
                height = grid[hIdx][vIdx]
                if maxGrid > height{
                    gridOffsetCount += maxGrid - height
                }                
            }
        }        
        return gridOffsetCount
    }
}

---

44ms

class Solution {
    func maxIncreaseKeepingSkyline(_ grid: [[Int]]) -> Int {
        let side = grid.compactMap{ $0.max() }
        let top = getTopSkyline(for: grid)
        
        guard grid.count > 0,
            top.count == side.count else {
                // invalid grid input
                return 0
            }
        
        let increase = computeMaxIncrease(for: grid, top: top, side:side)
        return increase
    }
    
    private func computeMaxIncrease(for grid:[[Int]], top: [Int], side:[Int]) -> Int {
        var increase = 0
        for i in 0..<top.count {
            for j in 0..<side.count {
                let topMax = top[i]
                let sideMax = side[j]
                let highest = min(top[i], side[j])
                
                increase += highest - grid[i][j]
            }
        }
        
        return increase
    }
    
    private func getTopSkyline(for grid:[[Int]]) -> [Int] {
        var top = [Int]()
        let length = grid.count
        for i in 0..<length {
            var maxValue = -1

            for j in 0..<length {
                maxValue = max(grid[j][i], maxValue)
            }
            top.append(maxValue)
        }
        
        return top
    }
}

---

Runtime: 48 ms

Memory Usage: 19.1 MB

class Solution {
    func maxIncreaseKeepingSkyline(_ grid: [[Int]]) -> Int {
        var m:Int = grid.count
        var n:Int = grid[0].count
        var res:Int = 0
        var row:[Int] = [Int](repeating:0,count:m)
        var col:[Int] = [Int](repeating:0,count:n)
        for i in 0..<m
        {
            for j in 0..<n
            {
                row[i] = max(row[i], grid[i][j])
                col[j] = max(col[j], grid[i][j])
            }
        }
        for i in 0..<m
        {
            for j in 0..<n
            {
                res += min(row[i] - grid[i][j], col[j] - grid[i][j])
            }
        }
        return res
    }
}

---

48ms

class Solution {
    func maxIncreaseKeepingSkyline(_ grid: [[Int]]) -> Int {
        let maxRow = grid.map { $0.max()! }
        let maxCol = getMaxCol(grid)
        let length = grid.count
        var out = 0
        
        for i in 0..<length {
            for j in 0..<length {
                let increase = min(maxRow[i], maxCol[j])
                let diff = increase - grid[i][j]
                out += diff
            }
        }
        
        return out
        
    }

    func getMaxCol(_ grid: [[Int]]) -> [Int] {
        var out = [Int]()
        for column in 0 ..< grid.count {
            out.append(grid.map { $0[ column ] }.max()!)
        }
        return out
    }
}

---

52ms

class Solution {
    func maxIncreaseKeepingSkyline(_ grid: [[Int]]) -> Int {
        let row_max = grid.map { $0.max()! }
        let col_max = (0..<grid[0].count).map { i in grid.map { $0[i] }.max()! }
        var count = 0
        for (i, row) in grid.enumerated() {
            for (j, el) in row.enumerated() {
                count += min(row_max[i], col_max[j]) - el
            }
        }
        return count
    }
}

---

56ms

class Solution {
    func maxIncreaseKeepingSkyline(_ grid: [[Int]]) -> Int {
        let row_maxes = grid.map { $0.max()! }
        let col_maxes = (0..<grid[0].count)
            .map { i in grid.reduce(0, { prev, next -> Int in max(prev, next[i]) }) }

        return zip(row_maxes, grid)
            .map { row_max, row in zip(col_maxes, row)
            .reduce(0, { prev, vals -> Int in prev + min(row_max, vals.0) - vals.1 }) }
            .reduce(0, +)
    }
}

---

64ms

class Solution {
    func maxIncreaseKeepingSkyline(_ grid: [[Int]]) -> Int {
        var result : Int = 0
        var rowMax :[Int] = []
        var colMax :[Int] = []
        for i in 0 ..< grid.count {
            rowMax.append(grid[i].max()!)
            colMax.append(grid.map{ $0[i] }.max()!)
        }
        
        for i in 0 ..< grid.count {
            for j in 0 ..< grid.count {
                result += min(rowMax[i],colMax[j]) - grid[i][j]
            }
        }
        return result
    }
}

---

72ms

class Solution {
    func maxIncreaseKeepingSkyline(_ grid: [[Int]]) -> Int {
    let rowsMaxes = grid.map { $0.max() ?? 0 }
    let columnsMaxes = getVerticalView(of: grid).map { $0.max() ?? 0 }
    
    return grid.enumerated().map { (arg) -> Int in
        
        let (i, _) = arg
        return grid[i].enumerated().map { (j, _) -> Int in
            let newTotal = min(rowsMaxes[i], columnsMaxes[j])
            return newTotal - grid[i][j]
        }.reduce(0, +)
    }.reduce(0, +)
}

fileprivate func getVerticalView(of grid: [[Int]]) -> [[Int]] {
    return (0..<grid[0].count).map { index -> [Int] in
        return grid.map { $0[index] }
    }
  } 
}

---

76ms

class Solution {
    func maxIncreaseKeepingSkyline(_ grid: [[Int]]) -> Int {
        var horizontalSkyline = [Int:Int]()
        var verticalSkyline = [Int:Int]()
        for (hIndex, row) in grid.enumerated() {
            var skyline = 0
            for (vIndex, element) in row.enumerated() {
                skyline = max(skyline, element)
                verticalSkyline[vIndex] = max(verticalSkyline[vIndex] ?? 0, element)
            }
            horizontalSkyline[hIndex] = skyline 
        }
        var sum = 0
        for (hIndex, row) in grid.enumerated() {
            for (vIndex, element) in row.enumerated() {
                sum += min(verticalSkyline[vIndex] ?? 0, horizontalSkyline[hIndex] ?? 0) - element
            }
        }
        return sum
    }
}