【leetcode】String——Longest Valid Parentheses（32）

题目：

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

For "(()", the longest valid parentheses substring is "()", which has length = 2.

Another example is ")()())", where the longest valid parentheses substring is "()()", which has length = 4.

思路1：新建一个标记数组，标记s中匹配的位置，最后判断最长连续出现的标记。 时间复杂度：O(n)

代码1：

第一次提交：超时了

   public int longestValidParentheses(String s) {
        
    	int[]flag = new int[s.length()];
    	
    	Stack<Character> stack = new Stack<Character>();
    	Stack<Integer> stackIndex = new Stack<Integer>();
    	char[] cc = s.toCharArray();
    	for(int i=0;i<cc.length;i++){
    		if(stack.isEmpty()){
    			stack.push(cc[i]);
    			stackIndex.push(i);
    		}
    		else if(cc[i]=='('){
    			stack.push(cc[i]);
    			stackIndex.push(i);
    		}
    		else if(cc[i]==')'){
    			if(stack.peek()=='('){  //match
    				stack.pop();
    				flag[i]=1;
    				flag[stackIndex.pop()]=1;
    			}else if(stack.peek()==')'){  //not match
    				stack.push(cc[i]);
        			stackIndex.push(i);
    			}
    		}
    	}
    	
    	int maxLen = 0;
    	int curLen = 0;
    	for(int i=0;i<s.length();i++){
    		if(flag[i]==1){
    			curLen++;
    			maxLen = Math.max(maxLen, curLen);
    		}else{
    			curLen=0;
    		}
    	}
    	return maxLen;
    
    }

借鉴网上帖子优化了自己的算法：

因为要记录匹配上的位置，所以，异常的情况可以不入stack，比如出现）且stack为空。

其实算法还可以优化，不需要stack，只需要stackIndex即可。

public int longestValidParentheses(String s) {
	int[]flag = new int[s.length()];
	
	Stack<Character> stack = new Stack<Character>();
	Stack<Integer> stackIndex = new Stack<Integer>();
	char[] cc = s.toCharArray();
	for(int i=0;i<cc.length;i++){
		if(cc[i]=='('){
			stack.push(cc[i]);
			stackIndex.push(i);
		}
		else if(cc[i]==')'&&!stack.isEmpty()){
				stack.pop();
				flag[i]=1;
				flag[stackIndex.pop()]=1;
		}
	}
	
	int maxLen = 0;
	int curLen = 0;
	for(int i=0;i<s.length();i++){
		if(flag[i]==1){
			curLen++;
			maxLen = Math.max(maxLen, curLen);
		}else{
			curLen=0;
		}
	}
	return maxLen;
}

思路2：动态规划。逆向的dp。dp[s.length]=0; dp[i]  i:s.length-2~0  

dp[i]记录从i开始（包含i），到s末尾，最长匹配的长度。

如果i位置是),dp[i]=0;

 如果是(,在s中寻找从i + 1开始的有效括号匹配子串长度，即dp[i + 1]，跳过这段有效的括号子串，查看下一个字符，其下标为j = i + 1 + dp[i + 1]。若j没有越界，并且s[j] == ‘)’，则s[i ... j]为有效括号匹配，dp[i] =dp[i + 1] + 2。
在求得了s[i ... j]的有效匹配长度之后，若j + 1没有越界，则dp[i]的值还要加上从j + 1开始的最长有效匹配，即dp[j + 1]。

代码2：

public int longestValidParentheses_dp(String s){
	if(s.equals(""))
		return 0;
	int max =0;
	int dp[] = new int[s.length()];
	dp[s.length()-1]=0;
	for(int i=s.length()-2;i>=0;i--){
		if(s.charAt(i)=='('){
			int j=i+1+dp[i+1];
			if(j<s.length()){
				if(s.charAt(j)==')'){
					dp[i] = dp[i+1]+2;
					if(j+1<s.length()){
						dp[i]+=dp[j+1];
					}
				}
			}
			
		}
		max = Math.max(max, dp[i]);
	}
	
	
	return max;
}