[Swift]LeetCode32. 最长有效括号 | Longest Valid Parentheses

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

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

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

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

Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.

Example 1:

Input: "(()"
Output: 2
Explanation: The longest valid parentheses substring is "()"

Example 2:

Input: ")()())"
Output: 4
Explanation: The longest valid parentheses substring is "()()"

---

给定一个只包含 '(' 和 ')' 的字符串，找出最长的包含有效括号的子串的长度。

示例 1:

输入: "(()"
输出: 2
解释: 最长有效括号子串为 "()"

示例 2:

输入: ")()())"
输出: 4
解释: 最长有效括号子串为 "()()"

---

【使用堆栈】算法

我们可以在扫描给定字符串时使用堆栈来检查目前为止扫描的字符串是否有效，以及最长有效字符串的长度，而不是查找每个可能的字符串并检查其有效性。为了做到这一点，我们从推动开始-1- 1到堆栈。

每一个 \文本{'（'}'（'遇到，我们将其索引推入堆栈。

每一个 \文本{'）'}'）'遇到，我们弹出最顶层的元素并从堆栈的顶部元素中减去当前元素的索引，这给出了当前遇到的有效括号字符串的长度。如果在弹出元素时，堆栈变空，我们将当前元素的索引推送到堆栈。通过这种方式，我们继续计算有效子串的长度，并在结尾返回最长有效字符串的长度。

2828ms

class Solution {
    func longestValidParentheses(_ s: String) -> Int {
        var maxans:Int = 0
        var stack:Stack<Int> = Stack<Int>()
        stack.push(-1)
        for i in 0..<s.count
        {
            if s.charAt(i) == "("
            {
                stack.push(i)
            }
            else
            {
                stack.pop()
                if stack.isEmpty()
                {
                    stack.push(i)
                }
                else
                {
                    maxans = max(maxans, i - stack.getLast()!)
                }
            }
        }
        return maxans
    }
}
extension String {
    //获取指定索引位置的字符，返回为字符串形式
    func charAt(_ num:Int) -> String
    {
        let index = self.index(self.startIndex,offsetBy: num)
        return String(self[index])
    }
}

public struct Stack<T> {
    
    // 泛型数组：用于存储数据元素
    fileprivate var stack: [T] 


    /// 构造函数：创建一个空的堆栈
    public init() {
        stack = [T]()
    }
    
    //通过既定数组构造堆栈
    init(_ arr:[T]){
        stack = arr
    }
    
    // 如果定义了默认值，则可以在调用函数时省略该参数
    init(_ elements: T...) {
        stack = elements
    }
    
    // 检查堆栈是否为空
    // - returns: 如果堆栈为空，则返回true，否则返回false
    public func isEmpty() -> Bool {
        return stack.isEmpty
    }
    
    // 入堆栈操作：将元素添加到堆栈的末尾
    public mutating func push(_ element: T) {
        stack.append(element)
    }
    
    // 出堆栈操作：删除并返回堆栈中的第一个元素
    public mutating func pop() -> T? {
        return stack.removeLast()
    }
 
    // 返回堆栈中的第一个元素(不删除)
    public func getLast() -> T? {
        return stack.last!
    }
}

---

16ms

class Solution {
    func longestValidParentheses(_ s: String) -> Int {
        let s = Array(s.characters)
        let len = s.count
        var max = Array(repeating: 0, count: len)
        var i = len-2
        var res = 0
        while i >= 0 {
            // find max[i]
            if s[i] == ")" {
                i -= 1
                continue
            }
            
            // s[i] = '('
            if s[i+1] == ")" {
                max[i] = 2 + (i < len-2 ? max[i+2] : 0)
            } else {
                let j = i + 1 + max[i+1];
                if j < len && s[j] == ")" {
                    max[i] = 2 + max[i+1] + (j < len-1 ? max[j+1] : 0)
                }
            }
            
            if max[i] > res { res = max[i] }
            
            i -= 1
        }
        
        return res
    }
}

---

20ms

class Solution {
    func longestValidParentheses(_ s: String) -> Int {
        
        guard s.count>0 else { return 0}
        
        var dp = Array(repeating:0,count:s.count)
        var sarr = Array(s.characters)
        var maxLen = 0
    
        //print(sarr)
        for i in 1..<sarr.count {
            if(sarr[i]==")") {
                if(sarr[i-1]=="(") {  //()
                dp[i] = (i>=2 ? dp[i-2]: 0) + 2
                //print("i:",i,"dp[i]:",dp[i])
                
                }
                else {  // ))
                    var prevIdx = i-dp[i-1]-1
                    //print("prevIdx:",prevIdx)
                    //print(dp)
                
                    if(prevIdx>=0 && sarr[prevIdx] == "(") {  //We found another enclosing parantheses
                        dp[i] = dp[i-1] + 2 + (prevIdx-1>=0 ? dp[prevIdx-1] : 0)
                    }
                }
            }
        
            if(dp[i]>=0) {
                maxLen = max(dp[i],maxLen)
            }
        }
    
        return maxLen
    }
}

---

24ms

class Solution {
    func longestValidParentheses(_ s: String) -> Int {
        if s.count == 0{
            return 0
        }
        
        var stack = [Int]()
        stack.append(-1)
        var arr = Array(s)
        var res = 0
        for i in 0..<arr.count{
            if arr[i] == ")"{
                if stack.count > 1 && arr[stack.last!] == "("{
                    stack.removeLast()
                    res = max(res, i - stack.last!)
                }else{
                    stack.append(i)
                }
            }else{
                stack.append(i)
            }
        }
        return res
    }
}

---

40ms

class Solution {
    func longestValidParentheses(_ s: String) -> Int {
        typealias Element = (index: Int, isOpening: Bool)
        var stack = [Element]()
        var maxCount = 0
        for (i, char) in s.enumerated() {
            if char == "(" {
                stack.append((index: i, isOpening: true))
            } else {
                if !stack.isEmpty && stack.last!.isOpening {
                    stack.removeLast()
                    let lastIndex = stack.last?.index ?? -1
                    let currentCount = i - lastIndex
                    maxCount = max(maxCount, currentCount)
                } else {
                    stack.append((index: i, isOpening: false))
                }
            }
        }
        return maxCount
    }
}

---

48ms

class Solution {
    func longestValidParentheses(_ s: String) -> Int {
        var stack: [Int] = [-1]
        var array = Array(s)
        var res = 0
        for i in 0..<array.count {
            if array[i] == "(" {
                stack.append(i)
            } else if array[i] == ")" {
                stack.removeLast()
                if !stack.isEmpty {
                    if (i - stack.last!) > res {
                        res = (i - stack.last!)
                    }
                } else {
                    stack.append(i)
                }   
            }
        }
        return res
    }
}

---

56ms

class Solution {
    func longestValidParentheses(_ s: String) -> Int {
        var stack = Array<String>()
        var indexStack = Array<Int>()
        var i = 0
        for c in s{
            if c == ")"{
                if stack.count == 0 || stack.last != "("{
                    stack.append(")")
                    indexStack.append(i)
                }else{
                    stack.removeLast()
                    indexStack.removeLast()
                }
            }else{
                stack.append("(")
                indexStack.append(i)
            }
            i += 1
        }
        var maxLength = 0
        var lastIndex = -1
        indexStack.append(s.count)
        for i in indexStack{
            let length = i - lastIndex - 1
            maxLength = maxLength < length ? length : maxLength
            lastIndex = i
        }
        return maxLength
    }
}

---

72ms

class Solution {
    func longestValidParentheses(_ s: String) -> Int {
        var stack = [-1]
        var left = 0 // 左括号剩余
        
        for char in s {
            if char == "(" {
                stack.append(0)
                left += 1
            } else {
                if left > 0 {
                    left -= 1
                    let top = stack.last!
                    stack.removeLast()
                    let second = stack.last!
                    if top == 0 { // 左边即是括号
                        if second == -1 || second == 0 { // 边界 或 左括号
                            stack.append(2)
                        } else { // 数字
                            stack.removeLast()
                            stack.append(second + 2)
                        }
                    } else { // 数字
                        // 因为左括号数量大于0  因此second只能为左括号
                        stack.removeLast()
                        let third = stack.last!
                        if third == -1 || third == 0 {
                            stack.append(top + 2)
                        } else { // 加上前一个数字
                            stack.removeLast()
                            stack.append(third + top + 2)
                        }
                    }
                } else {
                    stack.append(-1)
                }
            }
        }
        
        var result = 0
        for answer in stack {
            result = max(answer, result)
        }
        return result
    }
}

---

88ms

class Solution {
    func longestValidParentheses(_ s: String) -> Int {
        var stack: [Character] = []     // 模拟一个栈
        var symbols: [Int] = []         // 将括号打标记，遇到 ( 标记为-1，遇到 ) 判断是否与栈顶配对，如果配对打标记1，否则打标记-1
        
        for c in s {
            if c == "(" {
                stack.append(c)
                symbols.append(-1)
            } else if c == ")" {
                if stack.count > 0 && stack.last == "(" {
                    let _ = stack.removeLast()
                    symbols.append(1)
                } else {
                    stack.append(c)
                    symbols.append(-1)
                }
            }
        }
        
        var count: Int = 0          // 累加标记的数值
        var tmpLength: Int = 0      // 临时保存的最长序列的长度
        var maxLength: Int = 0      // 有效的最长序列的长度
        
        /*
         )()())  ->  -1 -1 1 -1 1 -1
         从右边遍历累加，成对的有效序列的和肯定是0，遇到-1，说明连续的序列断了，就重新累计
         */
        for num in symbols.reversed() {
            count += num
            
            if count == -1 {
                count = 0
                maxLength = max(maxLength, tmpLength)
                tmpLength = 0
            } else {
                tmpLength += 1
            }
        }
        
        if count == 0 {
            maxLength = max(maxLength, tmpLength)
        }
        
        return maxLength
    }
}