Leetcode抄答案之 32-最长有效括号

这个题其实我觉得和最长回文子串有点类似，可以用动态规划解决，虽然我想到了动态规划，但是因为我没想到状态方程，然后无解了，抄了一下点拨了一下，然后记录一下。
用了三个方法，一个是我的暴力法，一个是动态规划，然后是用栈判断。

暴力

就是官方题解说的，对每个子串进行判断，但是的确会超时。没什么好说的。

static int longestValidParentheses(String s) {
	int i=0,j=0,k=0,Length=0,Max=0;
	boolean Flag=true;
	Stack<Character> stack=new Stack<Character>();
	if (s.length()<=1)
		return 0;
	//起点
	for (i=0;i<s.length();i++){
		//终点
		for (j=i+1;j<s.length();j++){
			Flag=true;
			stack.clear();
			//遍历子串
			for (k=i;k<=j;k++){
				if (s.charAt(k)=='('){
					stack.push('(');
				}
				if (s.charAt(k)==')'){
					if (stack.isEmpty()){
						Flag=false;
					}
					else{
						stack.pop();			
					}
				}
			}
			//直接pass
			if (!Flag){
				continue;
			}
			System.out.println(stack.isEmpty());
			//还行，更新max
			if (stack.isEmpty()){	
				Length=j-i+1;
				System.out.println(i+"\t"+j+"\t"+Length);
				if (Length>Max && Length%2==0)
					Max=Length;
			}			
		}
	}
	return Max;
}

动态规划

遍历一次就可以了，首先分为两种情况

• ()()()：连续小括号
• …()…((…))：嵌套小括号

设置数组dp，记录以下标为i的字符结尾的长度为n的有效字符串。
首先遍历，先找到)，然后根据这两种情况分别找到对应的(，然后进行判断。
这里举个小例子
) () (()) (
若当i=5; s.chharAt(i)=’)’
若s.chharAt(i-1)=’(’，说明这是一个小括号，然后判断一下i是否在范围中，如果i<2，也就是i=1，说明这个小括号是第一次出现，否则就不是第一次出现。
如果是第一个出现，就直接是0+2。如果不是第一个，通过dp[i-2]判断这一对括号前面有没有有效的括号，如果为0，则没有，如果不为0，说明有，然后加上当前这两个小括号，就是dp[i]=dp[i-2]+2。

若i-dp[i-1]>0 && s.charAt(i-dp[i-1]-1)==’(’，即表示…))的括号形式。
用上面的例子说明一下，i=6，dp[i-1]=2，那么这个反括号对应的括号下标就应该是i-dp[i-1]-1=3，即为对应的(。
因此当对应的下标在范围中，且括号是(时，计算一下长度，首先要先加上前一个有效的括号dp[i-1]。
然后要考虑在这个大括号之前还有没有完整的有效的括号。如上面例子中，第二和第三个位置的()就属于这一部分。判断方法和上面其实一样，先判断下标是否符合范围，之前的末尾下标时i-dp[i-1]-2，如果这个值小于2，说明不存在完整的括号组，因此完整的括号组长度为0；然后如果大于等于2，说明可能存在括号组，至于真的存不存在，从i-dp[i-1]-2就可以得到了，因此之前部分的长度就是这个值。
然后还需要加上我们现在得到的新的括号，就是+2。
综上，第二种情况长度为dp[i]=dp[i-1]+((i-dp[i-1]-2)<2?0:dp[i-dp[i-1]-2])+2
然后就可以写代码了。

static int longestValidParentheses(String s) {
	int i=0,j=0,k=0,Length=0,Max=0;
	boolean Flag=true;
	int[] dp=new int[s.length()];
	Stack<Character> stack=new Stack<Character>();
	if (s.length()<=1)
		return 0;
	for (i=0;i<s.length();i++)
		dp[i]=0;
	for (i=1;i<s.length();i++){
		if (s.charAt(i)==')'){
			if (s.charAt(i-1)=='('){
				dp[i]=(i<2?0:dp[i-2])+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;
			}
			Max=Math.max(Max,dp[i]);
		}			
	}
	return Max;
}

栈

通过栈1次遍历也可以实现，这里规定栈顶只存放有效字符串的前一个字符下标。初始化的时候栈顶为-1。
例子：() ( ( ( (，有效字符串从0开始，栈顶则为-1。
然后当来一个(，入栈。
来一个)，就出栈，这时候继续判断，如果为空，说明当前这个不是一个匹配的)，因此需要继续入栈当前位置。如果不为空，说明匹配的已经完成了，此时计算一下长度，栈顶始终是上一个末尾元素，因此长度即为i=stack.peek()。这里如果一直不匹配括号的话，即都是反括号，会一直入栈出栈，栈中始终只有一个元素，即为上一个的末尾元素。
其实我觉得比动态规划难想。

static int longestValidParentheses(String s) {
	int i=0,j=0,k=0,Length=0,Max=0;
	Stack<Integer> stack=new Stack<Integer>();
	stack.push(-1);
	if (s.length()<=1)
		return 0;
	for (i=0;i<s.length();i++){
		if (s.charAt(i)=='(')
			stack.push(i);
		else{
			stack.pop();
			if (stack.isEmpty())
				stack.push(i);
			else{
				Max=Math.max(Max,i-stack.peek());
			}
		}		
	}
	return Max;
}