[Swift]LeetCode407. 接雨水 II | Trapping Rain Water II

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

Given an m x n matrix of positive integers representing the height of each unit cell in a 2D elevation map, compute the volume of water it is able to trap after raining. 

Note:

Both m and n are less than 110. The height of each unit cell is greater than 0 and is less than 20,000. 

Example:

Given the following 3x6 height map:
[
  [1,4,3,1,3,2],
  [3,2,1,3,2,4],
  [2,3,3,2,3,1]
]

Return 4.

The above image represents the elevation map [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]] before the rain. 

After the rain, water is trapped between the blocks. The total volume of water trapped is 4.

---

给定一个 m x n 的矩阵，其中的值均为正整数，代表二维高度图每个单元的高度，请计算图中形状最多能接多少体积的雨水。 

说明:

m 和 n 都是小于110的整数。每一个单位的高度都大于0 且小于 20000。 

示例：

给出如下 3x6 的高度图:
[
  [1,4,3,1,3,2],
  [3,2,1,3,2,4],
  [2,3,3,2,3,1]
]
返回 4。

如上图所示，这是下雨前的高度图[[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]] 的状态。 

下雨后，雨水将会被存储在这些方块中。总的接雨水量是4。

---

Runtime: 256 ms

Memory Usage: 19.1 MB

class Solution {
    func trapRainWater(_ heightMap: [[Int]]) -> Int {
        if heightMap.isEmpty {return 0}
        var m:Int = heightMap.count
        var n:Int = heightMap[0].count
        var res:Int = 0
        var mx:Int = Int.min
        var q = Heap<(Int, Int)>.init { (f, s) -> Bool in
            if f.0 == s.0
            {
                return f.1 < s.1
            }
            return f.0 < s.0
        }
        var visited:[[Bool]] = [[Bool]](repeating:[Bool](repeating:false,count:n),count:m)
        var dir:[[Int]] = [[0,-1],[-1,0],[0,1],[1,0]]
        for i in 0..<m
        {
            for j in 0..<n
            {
                if i == 0 || i == m - 1 || j == 0 || j == n - 1
                {
                    q.insert((heightMap[i][j], i * n + j))
                    visited[i][j] = true
                }
            }
        }
        while(!q.isEmpty)
        {
            var t:(Int, Int) = q.remove()!
            var h:Int = t.0
            var r:Int = t.1 / n
            var c:Int = t.1 % n
            mx = max(mx, h)
            for i in 0..<dir.count
            {
                var x:Int = r + dir[i][0]
                var y:Int = c + dir[i][1]
                if x < 0 || x >= m || y < 0 || y >= n || visited[x][y]
                {
                    continue
                }
                visited[x][y] = true
                if heightMap[x][y] < mx
                {
                    res += mx - heightMap[x][y]
                }
                q.insert((heightMap[x][y], x * n + y))
            }
        }
        return res
    }
}

public struct Heap<T> {
    public var nodes = [T]()
    private var orderCriteria: (T, T) -> Bool
    
    public init(sort: @escaping (T, T) -> Bool) {
        orderCriteria = sort
    }
    
    public init(array: [T], sort: @escaping (T, T) -> Bool) {
        self.orderCriteria = sort
        configureHeap(from: array)
    }
    
    public var isEmpty: Bool {
        return nodes.isEmpty
    }
    
    public var count: Int {
        return nodes.count
    }
    
    public mutating func configureHeap(from array: [T]) {
        nodes = array
        for i in stride(from: nodes.count / 2 - 1, through: 0, by: -1) {
            shiftDown(i)
        }
    }
    
    public mutating func reset() {
        for i in stride(from: nodes.count / 2 - 1, through: 0, by: -1) {
            shiftDown(i)
        }
    }
    
    @inline(__always) internal func parentIndex(ofIndex index: Int) -> Int {
        return (index - 1) / 2
    }
    
    @inline(__always) internal func leftChildIndex(ofIndex index: Int) -> Int {
        return index * 2 + 1
    }
    
    @inline(__always) internal func rightChildIndex(ofIndex index: Int) -> Int {
        return index * 2 + 2
    }
    
    public func peek() -> T? {
        return nodes.first
    }
    
    internal mutating func shiftUp(_ index: Int) {
        var childIndex = index
        let child = nodes[childIndex]
        var parentIndex = self.parentIndex(ofIndex: index)
        while childIndex > 0 && orderCriteria(child, nodes[parentIndex]) {
            nodes[childIndex] = nodes[parentIndex]
            childIndex = parentIndex
            parentIndex = self.parentIndex(ofIndex: childIndex)
        }
        nodes[childIndex] = child
    }
    
    internal mutating func shiftDown(from index: Int, until endIndex: Int) {
        let leftChildIndex = self.leftChildIndex(ofIndex: index)
        let rightChildIndex = self.rightChildIndex(ofIndex: index)
        
        var first = index
        if leftChildIndex < endIndex && orderCriteria(nodes[leftChildIndex], nodes[first]) {
            first = leftChildIndex
        }
        if rightChildIndex < endIndex && orderCriteria(nodes[rightChildIndex], nodes[first]) {
            first = rightChildIndex
        }
        if first == index {
            return
        }
        nodes.swapAt(index, first)
        shiftDown(from: first, until: endIndex)
    }
    
    internal mutating func shiftDown(_ index: Int) {
        shiftDown(from: index, until: nodes.count)
    }
    
    public mutating func insert(_ value: T) {
        nodes.append(value)
        shiftUp(nodes.count - 1)
    }
    
    public mutating func insert<S: Sequence>(_ sequence:S) where S.Iterator.Element == T {
        for value in sequence {
            insert(value)
        }
    }
    
    public mutating func replace(index i: Int, value: T) {
        guard i < nodes.count else {
            return
        }
        remove(at: i)
        insert(value)
    }
    
    @discardableResult
    public mutating func remove() -> T? {
        guard !nodes.isEmpty else {
            return nil
        }
        if nodes.count == 1 {
            return nodes.removeLast()
        } else {
            let value = nodes[0]
            nodes[0] = nodes.removeLast()
            shiftDown(0)
            return value
        }
    }
    
    @discardableResult
    public mutating func remove(at index: Int) -> T? {
        guard index < nodes.count else { return nil}
        let size = nodes.count - 1
        if index != size {
            nodes.swapAt(index, size)
            shiftDown(from: index,  until: size)
            shiftUp(index)
        }
        return nodes.removeLast()
    }
    
    public mutating func sort() -> [T] {
        for i in stride(from: self.nodes.count - 1, to: 0, by: -1) {
            nodes.swapAt(0, i)
            shiftDown(from: 0, until: i)
        }
        return nodes
    }
}

---

18952 kb

class Solution {
    struct MinHeap<Element> where Element: Comparable {
        var values: [Element] = []

        func min() -> Element? {
            return values.first
        }
        mutating func insert(_ element: Element) {
            var current = values.count
            values.append(element)

            while current > 0 {
                let parent = (current - 1) / 2

                if values[parent] > values[current] {
                    values.swapAt(parent, current)
                    current = parent
                } else {
                    break
                }
            }
        }

        mutating func removeMin() {
            guard !values.isEmpty else {
                return
            }

            let last = values.removeLast()
            guard !values.isEmpty else {
                return
            }
            replaceMin(with: last)
        }

        mutating func replaceMin(with element: Element) {
            guard !values.isEmpty else {
                values = [element]
                return
            }
            values[0] = element

            var current = 0
            while true {
                let leftIndex = current * 2 + 1
                let rightIndex = current * 2 + 2

                guard leftIndex < values.count else {
                    break
                }

                var child: Int
                if rightIndex >= values.count || values[leftIndex] < values[rightIndex] {
                    child = leftIndex
                } else {
                    child = rightIndex
                }

                if values[child] < values[current] {
                    values.swapAt(child, current)
                    current = child
                } else {
                    break
                }
            }
        }
    }

    struct Item: Comparable {
        var row, column: Int
        var height: Int

        static func <(_ lhs: Item, _ rhs: Item) -> Bool {
            return lhs.height < rhs.height
        }

        func validNeighbour(rowCount: Int, columnCount: Int) -> [(row: Int, column: Int)] {
            var result: [(row: Int, column: Int)] = []
            if row > 0 {
                result.append((row - 1, column))
            }
            if row < rowCount - 1 {
                result.append((row + 1, column))
            }
            if column > 0 {
                result.append((row, column - 1))
            }
            if column < columnCount - 1 {
                result.append((row, column + 1))
            }

            return result
        }
    }

    func trapRainWater(_ heightMap: [[Int]]) -> Int {
        let rowCount = heightMap.count, columnCount = heightMap.first?.count ?? 0

        guard rowCount > 2, columnCount > 2 else {
            return 0
        }

        var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: columnCount), count: rowCount)
        var boundaries = MinHeap<Item>()

        for row in 0..<rowCount {
            visited[row][0] = true
            visited[row][columnCount - 1] = true

            boundaries.insert(Item(row: row, column: 0, height: heightMap[row][0]))
            boundaries.insert(Item(row: row, column: columnCount - 1, height: heightMap[row][columnCount - 1]))
        }
        for column in 1..<(columnCount - 1) {
            visited[0][column] = true
            visited[rowCount - 1][column] = true

            boundaries.insert(Item(row: 0, column: column, height: heightMap[0][column]))
            boundaries.insert(Item(row: rowCount - 1, column: column, height: heightMap[rowCount - 1][column]))
        }

        var total = 0
        while let boundary = boundaries.min() {
            boundaries.removeMin()
            let boundaryHeight = boundary.height

            for (row, column) in boundary.validNeighbour(rowCount: rowCount, columnCount: columnCount) {
                guard !visited[row][column] else {
                    continue
                }

                let currentHeight = heightMap[row][column]
                let newHeight: Int

                if currentHeight > boundaryHeight {
                    newHeight = currentHeight
                } else {
                    total += boundary.height - currentHeight
                    newHeight = boundaryHeight
                }
                visited[row][column] = true

                boundaries.insert(Item(row: row, column: column, height: newHeight))
            }
        }
        return total
    }
}