[Swift]LeetCode84. 柱状图中最大的矩形 | Largest Rectangle in Histogram

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

Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

The largest rectangle is shown in the shaded area, which has area = 10 unit.

Example:

Input: [2,1,5,6,2,3]
Output: 10

---

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为 [2,1,5,6,2,3]。

图中阴影部分为所能勾勒出的最大矩形面积，其面积为 10 个单位。

示例:

输入: [2,1,5,6,2,3]
输出: 10

---

44ms

class Solution {
    func largestRectangleArea(_ heights: [Int]) -> Int {
            
    if heights.count == 0 {
        return 0
    }
        
            if heights.count == 1 {
        return heights[0]
    }
    var leftIndexes = Array<Int>.init(repeating: 0, count: heights.count)
    var rightIndexes = Array<Int>.init(repeating: 0, count: heights.count)
    leftIndexes[0] = -1
    rightIndexes[heights.count - 1] = heights.count
    
    for i in 1..<heights.count {
        var p = i - 1
        while p >= 0, heights[p] >= heights[i] {
            p = leftIndexes[p]
        }
        leftIndexes[i] = p
    }
    
    for i in (0...heights.count - 2).reversed() {
        var p = i + 1
        while p < heights.count, heights[p] >= heights[i] {
            p = rightIndexes[p]
        }
        rightIndexes[i] = p
    }
    var maxArea = 0
    for i in 0..<heights.count {
        maxArea = max(maxArea, heights[i] * (rightIndexes[i] - leftIndexes[i] - 1))
    }

    return maxArea
    }
}

---

64ms

class Solution {
    func largestRectangleArea(_ heights: [Int]) -> Int {
        
        let heights = heights + [0]
        
        var indexStack: [Int] = []
        var maxHeight = 0
        
        for (i,height) in heights.enumerated() {
            
            while let previousIndex = indexStack.last, heights[previousIndex] > height {
                indexStack.removeLast()
                
                let lastIndex = indexStack.last ?? -1
                let width = (i-1) - lastIndex
                let height = heights[previousIndex]
                
                maxHeight = max(maxHeight, width * height)
            }
            
            indexStack.append(i)
        }
        
        return maxHeight
    }
}

---

72ms

class Solution {
    func largestRectangleArea(_ heights: [Int]) -> Int {
        
        var stack = [Int]()
        var bestSolution = 0
        var currentHeight = 0
        
        for i in 0..<heights.count {
            
            currentHeight = heights[i]
            if currentHeight > bestSolution {
                //bestSolution = currentHeight
            }
            
            while stack.last != nil && currentHeight <= heights[stack.last!]  {
                
                var lastIndex = stack.last!
                var lastHeight = heights[lastIndex]
                stack.removeLast()
                
                var index = stack.isEmpty ? i : (i - 1 - stack.last!)
                var rectHeight = lastHeight * (index)
                
                if rectHeight > bestSolution {
                    bestSolution = rectHeight
                }
            }
            
            stack.append(i)
        }
        
        while stack.last != nil {
            
            var lastIndex = stack.last!
            var lastHeight = heights[lastIndex]
            stack.removeLast()
                
            var index = stack.isEmpty ? (heights.count) : ((heights.count) - 1 - stack.last!)
            var rectHeight = lastHeight * (index)
            
            if rectHeight > bestSolution {
                bestSolution = rectHeight
            }
        }
        
        return bestSolution
    }
}

---

76ms

class Solution {
    func largestRectangleArea(_ heights: [Int]) -> Int {
        
        if heights.count == 0 {
            return 0
        }
        
        var myHeights: [Int] = heights
        myHeights.append(0)

        var s = 0
        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
    }
}

---

88ms

class Solution {
    func largestRectangleArea(_ heights: [Int]) -> Int {
        var left: [Int] = Array(repeating: 0, count: heights.count)
        var right: [Int] = Array(repeating: 0, count: heights.count)
        var sums: [Int] = Array(repeating: 0, count: heights.count)
        
        for index in 0..<heights.count {
            var indexToLeft = index
            while indexToLeft > 0 {
                if heights[indexToLeft - 1] >= heights[index] {
                    indexToLeft -= 1 + left[indexToLeft-1]
                } else {
                    break
                }
            }
            
            left[index] = index-indexToLeft
        }
        
        for index in (0..<heights.count).reversed() {
            var indexToRight = index
            while (indexToRight + 1) < heights.count {
                if heights[indexToRight + 1] >= heights[index] {
                    indexToRight += 1 + right[indexToRight+1]
                } else {
                    break
                }
            }
            
            right[index] = indexToRight - index
        }
        
        var maxSum = 0
        for index in 0..<heights.count {
            sums[index] = heights[index] * (left[index] + 1 + right[index])
            maxSum = max(maxSum, sums[index])
        }
        return maxSum        
    }
}

---

96ms

class Solution {
    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
    }
}

---

148ms

class Solution {
    func largestRectangleArea(_ heights: [Int]) -> Int {
        if heights.isEmpty {return 0}
        var stack = [0], maxArea = 0
        var i = 1
        while i < heights.count || !stack.isEmpty {
            if i < heights.count && (stack.isEmpty || heights[i] >= heights[stack.last!]) {
                stack.append(i)
                i += 1
            } else {
                let curr = stack.popLast()!
                let leftBound = stack.isEmpty ? -1 : stack.last!
                let currArea = heights[curr] * (i - 1 - leftBound)
                maxArea = max(maxArea, currArea)
            }
        }
        return maxArea
    }
}

---

236ms

class Solution {
    func largestRectangleArea(_ heights: [Int]) -> Int {
        var stack = [Int]()
        var res = 0
        for i in 0...heights.count {
            let curr = i == heights.count ? 0 : heights[i]
            while !stack.isEmpty && heights[stack[0]] > curr {
                let height = heights[stack.removeFirst()]
                let width = stack.isEmpty ? i : i - 1 - stack[0]
                res = max(res, height * width)
            }
            stack.insert(i, at: 0)
        }
        return res
    }
}