[Swift]LeetCode85. 最大矩形 | Maximal Rectangle

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

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

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

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

Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area.

Example:

Input:
[
  ["1","0","1","0","0"],
  ["1","0","1","1","1"],
  ["1","1","1","1","1"],
  ["1","0","0","1","0"]
]
Output: 6

---

给定一个仅包含 0 和 1 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。

示例:

输入:
[
  ["1","0","1","0","0"],
  ["1","0","1","1","1"],
  ["1","1","1","1","1"],
  ["1","0","0","1","0"]
]
输出: 6

---

160ms

class Solution {
    func maximalRectangle(_ matrix: [[Character]]) -> Int {
        if matrix.count == 0 || matrix[0].count == 0{
            return 0
        }
        var ans = 0
        var rowArr = Array(repeating:0,count:matrix[0].count + 1)
        for y in stride(from:0,to:matrix.count,by:1) {
            for x in stride(from:0,to:matrix[0].count,by:1) {
                if matrix[y][x] == "1" {
                    rowArr[x] += 1 
                } else {
                    rowArr[x] = 0
                }
            }
            ans = max(ans,getLargetRect(rowArr))
        }
        return ans
    }
    
    func getLargetRect(_ rowArr:[Int]) -> Int {
        var stack = [Int]()
        var maxArea = 0
        for (index,height) in rowArr.enumerated() {
            while let last = stack.last, rowArr[last] > height {
                stack.removeLast()
                var width = 0
                if stack.isEmpty {
                    width = index
                } else {
                    width = index - stack.last! - 1
                }
                maxArea = max(maxArea, width * rowArr[last] )
            }

            stack.append(index)
        }
        return maxArea
    }
}

---

168ms

class Solution {
    func maximalRectangle(_ matrix: [[Character]]) -> Int {
        let n = matrix.count
        guard n > 0 else {
            return 0
        }
        let m = matrix[0].count
        
        var mark = Array(repeatElement(Array(repeatElement(0, count: m)), count: n))
        for i in (0..<n).reversed() {
            var count = 0
            for j in (0..<m).reversed() {
                if matrix[i][j] == "1" {
                    count += 1
                } else {
                    count = 0
                }
                mark[i][j] = count
            }
        }

        var result = 0
        for i in 0..<n {
            for j in 0..<m {
                var minColumn = m
                var row = i
                while row < n && mark[row][j] != 0 {
                    minColumn = min(minColumn, mark[row][j])
                    result = max(result, (row - i + 1) * minColumn)
                    row += 1
                }
            }
        }
        return result
    }
}

---

200ms

class Solution {

    func maximalRectangle(_ matrix: [[Character]]) -> Int {
        
        if matrix.count == 0 || matrix[0].count == 0 {
            return 0
        }
        
        var heights = [Int](repeating: 0, count: matrix[0].count)
        var s = 0
        
        for i in 0..<matrix.count {
            
            for j in 0..<matrix[i].count {
                
                if matrix[i][j] == "1" {
                    
                    heights[j] += 1
                    
                } else {
                    heights[j] = 0
                }
            }
            
            s = max(s, largestRectangleArea(heights))
        }
        
        return s
    }
    
    func largestRectangleArea(_ heights: [Int]) -> Int {
        
        if heights.count == 0 {
            return 0
        }
        
        var myHeights: [Int] = heights
        myHeights.append(0)
        
        
        var s = 0
        //swift中没有栈,使用数组代替,永远操作最后一位
        var stack: [Int] = []
        var i = 0
        
        while i < myHeights.count {
            
            if stack.count == 0 || myHeights[stack.last!] < myHeights[i] {
                
                stack.append(i)
                i += 1
            } else {
                
                let j = stack.last!
                stack.removeLast()
                
                //如果栈为空,说明数组第一位即构成矩形的左侧边界,此时索引大小即矩形长度
                //如果不为空,用栈顶索引和当前索引计算矩形长度
                s = max(s, myHeights[j]*(stack.isEmpty ? i : i - 1 - stack.last!))
            }
        }
        return s
    }
        
}

---

416ms

class Solution {
    func maximalRectangle(_ matrix: [[Character]]) -> Int {
        guard matrix.count > 0 && matrix[0].count > 0 else {
            return 0
        }
        let m = matrix.count
        let n = matrix[0].count
        var left = [Int](repeating: 0, count: n)
        var right = [Int](repeating: n, count: n)
        var height = [Int](repeating: 0, count: n)
        var result = 0
        for i in 0..<m {
            var currentLeft = 0
            var currentRight = n
            for j in 0..<n {
                if (matrix[i][j] == "1") {
                    left[j] = max(left[j], currentLeft)
                    height[j] = height[j] + 1
                } else {
                    left[j] = 0
                    currentLeft = j + 1
                    height[j] = 0
                }
                if (matrix[i][n - j - 1] == "1") {
                    right[n - j - 1] = min(right[n - j - 1], currentRight)
                } else {
                    currentRight = n - j - 1
                    right[n - j - 1] = n
                }
            }
            for j in 0..<n {
                result = max(result, (right[j] - left[j]) * height[j])
            }
        }
        return result
    }
}

---

436ms

class HistoArea {
    func largestRectangleArea(_ heights: [Int]) -> Int {
        var stack = [Int]()
        var max = 0
        for i in 0..<heights.count {
            if stack.count == 0 || heights[i]>=heights[stack[stack.count-1]] {
                stack.append(i)
            } else {
                while stack.count > 0 && heights[i] < heights[stack[stack.count-1]] {
                    let area = eval(&stack, heights, i)
                    if area > max {
                        max = area
                    }
                }
                stack.append(i)
            }
        }
        while stack.count > 0 {
            let area = eval(&stack, heights, heights.count)
            if area > max {
                max = area
            }
        }
        return max
    }
    
    func eval(_ stack: inout [Int], _ heights: [Int], _ end: Int) -> Int {
        let idx = stack.last!
        stack.removeLast()
        var area = 0

        if let start = stack.last {
            area = heights[idx]*(end-start-1)
        } else {
            area = heights[idx]*end
        }
        return area
    }
}

class Solution {
    func maximalRectangle(_ matrix: [[Character]]) -> Int {
        let hist = HistoArea()
        var histogram = [Int]()
        if matrix.count == 0 {
            return 0
        }
        for i in 0..<matrix[0].count {
            histogram.append(0)
        }
        var maxArea = 0
        
        for i in 0..<matrix.count {
            for j in 0..<matrix[0].count {
                if matrix[i][j] == "1" {
                    histogram[j] += 1
                } else {
                    histogram[j] = 0
                }
            }
            let area = hist.largestRectangleArea(histogram)
            if area > maxArea {
                maxArea = area
            }
        }
        return maxArea
    }
}

---

452ms

class Solution {
    func maximalRectangle(_ matrix: [[Character]]) -> Int {
        if matrix.count == 0 || matrix[0].count == 0 {
            return 0
        }

        let rLen = matrix.count
        let cLen = matrix[0].count
        var h = [Int](repeating: 0, count: cLen + 1)
        var maxValue = 0

        for row in 0..<rLen {
            var stack = [Int]()
            for i in 0..<(cLen + 1) {
                if i < cLen {
                    if matrix[row][i] == "1" {
                        h[i] += 1
                    } else {
                        h[i] = 0
                    }
                }
                if stack.isEmpty || h[stack.last!] <= h[i] {
                    stack.append(i)
                } else {
                    while !stack.isEmpty && h[i] < h[stack.last!] {
                        let top = stack.removeLast()
                        let area = h[top] * (stack.isEmpty ? i : (i - stack.last! - 1))
                        if area > maxValue {
                            maxValue = area
                        }
                    }
                    stack.append(i)
                }
            }
        }
        return maxValue
    }
}

---

588ms

class Solution {
    func maximalRectangle(_ matrix: [[Character]]) -> Int {
        let n = matrix.count
        guard n > 0 else {
            return 0
        }
        let m = matrix[0].count
        
        var mark = Array(repeatElement(Array(repeatElement(0, count: m)), count: n))
        for i in (0..<n).reversed() {
            var count = 0
            for j in (0..<m).reversed() {
                if matrix[i][j] == "1" {
                    count += 1
                } else {
                    count = 0
                }
                mark[i][j] = count
            }
        }

        var result = 0
        for i in 0..<n {
            for j in 0..<m {
                var minColumn = m
                var row = i
                while row < n && mark[row][j] != 0 {
                    minColumn = min(minColumn, mark[row][j])
                    result = max(result, (row - i + 1) * minColumn)
                    row += 1
                }
            }
        }
        return result
    }
}