32. 最长有效括号--栈，动态规划

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

示例 1:

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

示例 2:

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

 

方法1：动态规划

这个问题可以通过动态规划解决。我们定义一个 dp 数组，其中第 i个元素表示以下标为 i的字符结尾的最长有效子字符串的长度。我们将 dp数组全部初始化为 0 。现在，很明显有效的子字符串一定以‘)’结尾。这进一步可以得出结论：以‘(’结尾的子字符串对应的 dp 数组位置上的值必定为 0 。所以说我们只需要更新 ‘)’ 在 dp 数组中对应位置的值。

为了求出 dp 数组，我们每两个字符检查一次，如果满足如下条件:

•    s[i]=‘)’且s[i−1]=‘(’，也就是字符串形如"……()"，我们可以推出：

                 dp[i]=dp[i−2]+2

    我们可以进行这样的计算，是因为结束部分的 ‘()’ 是一个有效子字符串，并且将之前有效子字符串的长度增加了 2 。

•    s[i]=‘)’且s[i−1]=‘)’，也就是字符串形如".......))" ，我们可以推出： 如果s[i−dp[i−1]−1]=‘(’ ，那么

              dp[i]=dp[i−1]+dp[i−dp[i−1]−2]+2

    这背后的原因是如果倒数第二个‘)’是一个有效子字符串的一部分（记为 sub​），对于最后一个‘)’，如果它是一个更长子字符串的一部分，那么它一定有一个对应的‘(’，它的位置在倒数第二个‘)’所在的有效子字符串的前面（也就是 sub​ 的前面）。

   因此，如果子字符串 sub 的前面恰好是‘(’，那么我们就用  2 加上 sub​ 的长度 dp[i−1] 去更新 dp[i] 。除此以外，我们也会把有效子字符串"(,subs​,)"之前的有效子字符串的长度也加上，也就是加上  dp[i−dp[i−1]−2]  。

 

public class ABCTest{
	public int longestValidParentheses(String s) {
		int maxans = 0;
		int[] dp = new int[s.length()];
		for(int i=1;i<s.length();i++) {
			if(s.charAt(i)==')') {
				if(s.charAt(i-1)=='(') //形如"...()"
					dp[i] = (i>=2? dp[i-2]:0)+2;
				else if(i-dp[i-1]>0 && s.charAt(i-dp[i-1]-1)=='(')
					dp[i] = dp[i-1]+ ((i-dp[i-1])>=2? dp[i-dp[i-1]-2]:0)+2;
                                        //形如"...())"
				
				maxans = Math.max(maxans, dp[i]);
			}
		}
		return maxans;
	}
}

复杂度分析

    时间复杂度： O(n) 。遍历整个字符串一次，就可以将 dp 数组求出来。
    空间复杂度： O(n) 。需要一个大小为 n 的 dp 数组。

 

 

 

方法2：暴力法

在这种方法中，我们考虑给定字符串中每种可能的非空偶数长度子字符串，检查它是否是一个有效括号字符串序列。

为了检查有效性，我们使用栈的方法。

每当我们遇到一个  ‘(’  ，我们把它放在栈顶。对于遇到的每个 ‘)’ ，我们从栈中弹出一个  ‘(’ ，如果栈顶没有 ‘(’，或者遍历完整个子字符串后栈中仍然有元素，那么该子字符串是无效的。这种方法中，我们对每个偶数长度的子字符串都进行判断，并保存目前为止找到的最长的有效子字符串的长度。

例子:
"((())"

(( --> 无效
(( --> 无效
() --> 有效，长度为 2
)) --> 无效
((()--> 无效
(())--> 有效，长度为 4
最长长度为 4

public class ABCTest{
	 public boolean isValid(String s) {
		 Stack<Character> stack = new Stack<Character>(); 
		 for (int i = 0; i < s.length(); i++) {
			 if (s.charAt(i) == '(') { 
				 stack.push('('); 
			 } else if (!stack.empty() && stack.peek() == '(') {
				 stack.pop(); } else { return false;
			}
		 } 
		 return stack.empty();
	} 
	 
	public int longestValidParentheses(String s) {
		int maxlen = 0;
		for (int i = 0; i < s.length(); i++) {
			for (int j = i + 2; j <= s.length(); j+=2) {
				if (isValid(s.substring(i, j))) {
					maxlen = Math.max(maxlen, j - i);
				} 
			}
		} 
		return maxlen; 
	}
}

复杂度分析

    时间复杂度： O(n2)。从长度为 n 的字符串产生所有可能的子字符串需要的时间复杂度为 O(n2) 。验证一个长度为 n 的子字符串需要的时间为 O(n) 。
    空间复杂度： O(n) 。子字符串的长度最多会需要一个深度为 n 的栈。