leetcode 32 最长有效括号

[toc]

1. 最长有效括号

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

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

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

1.1. 暴力穷举

略，详见代码

1.2. 动态规划

首先，可以明确的是合法的子串一定是以 ')' 结尾，所以，只需要关心s 中的 ')' 字符。

状态转移方程式：
if s[i] == ')' and s[i-1] == '('  
dp[i] = dp[i-2] +2

if s[i] == ')' and s[i-1] == ')'  
如果它是一个合法子串的结尾，那么一定有一个对应的 '(' 在前方，且两者之间的子串也是合法的。  
所以，假设dp[i-1] = x  
那么 s[i-1-x+1:i]一定是合法子串，且s[i-1-x]一定是 '('  
dp[i] = dp[i-1] + 2 +dp[i - dp[i-1] - 2]  
第三项的含义是可能前方仍有合法子串；

2. 代码

# coding:utf-8

__author__ = "sn"

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

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

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

"""
思路：
暴力穷举
动态规划

"""

class Solution:
    def longestValidParentheses_1(self, s: str) -> int:
        """
        暴力法
        时间复杂度：O(N^2)
        空间复杂度：O(N)
        :param s:
        :return:
        """

        max_length = 0
        s_len = len(s)
        for i in range(s_len):
            if s[i] == '(':
                tmp, stack = 0, ['(',]
                for j in range(i+1, s_len):
                    if s[j] == '(':
                        stack.append(s[j])
                    elif len(stack) > 0:
                        stack.pop()
                        tmp += 2
                    else:
                        break

                max_length = max(max_length, tmp)
        return max_length

    def longestValidParentheses_2(self, s: str) -> int:
        """
        动态规划
        时间复杂度：O(N)
        空间复杂度：O(N)
        :param s:
        :return:
        """
        max_length = 0
        if len(s) < 2: return 0
        dp = [0 for _ in range(len(s))]

        for i in range(1, len(s)):
            if s[i] == ')' and s[i-1] == '(':
                # 边界处理
                t = 0 if i < 2 else dp[i-2]
                dp[i] = t + 2
            elif s[i] == ')' and s[i-1] == ')' and s[i-1-dp[i-1]] == '(':
                # 边界处理
                t = 0 if i-dp[i-1]-2 <=0 else dp[i-dp[i-1]-2]
                dp[i] = dp[i-1] + 2 + t
            max_length = max(max_length, dp[i])
        return max_length

    def longestValidParentheses_3(self, s: str) -> int:
        """
        栈
        时间复杂度： O(n)
        空间复杂度： O(n) 栈的大小最大达到 n 。
        :param s:
        :return:
        """
        max_length = 0
        stack = []
        stack.append(-1)
        for i in range(len(s)):
            if s[i] == '(':
                stack.append(i)
            else:
                stack.pop()
                if not stack:stack.append(i)
                else:
                    max_length = max(max_length, i - stack[-1])
        return max_length




# 测试代码
from processing_time import test_func, processing_func

if __name__ == "__main__":
    # 实例化解决方案类
    so = Solution()

    # 参数设定
    s = '()))'
    #s = '())'
    para = (s, )

    test_func(so, para)
    pass

2.1. 输出

 共有<3>个方法： ['longestValidParentheses_1', 'longestValidParentheses_2', 'longestValidParentheses_3']
测试参数:('()))',)

 **************************************** 
方法[1]：longestValidParentheses_1
说明：暴力法
        时间复杂度：O(N^2)
        空间复杂度：O(N)
        :param s:
        :return:
执行结果： 2

 **************************************** 
方法[2]：longestValidParentheses_2
说明：动态规划
        时间复杂度：O(N)
        空间复杂度：O(N)
        :param s:
        :return:
执行结果： 2

 **************************************** 
方法[3]：longestValidParentheses_3
说明：时间复杂度： O(n)
        空间复杂度： O(n) 栈的大小最大达到 n 。
        :param s:
        :return:
执行结果： 2

执行时长：
('longestValidParentheses_1', 9.657220008266953e-05)
('longestValidParentheses_2', 4.012178360922504e-05)
('longestValidParentheses_3', 3.265726572843899e-05)

Process finished with exit code 0