《DP学习系列》Longest Valid Parentheses的一些DP细节思考-CSDN博客

本文链接：https://blog.csdn.net/LoveStackover/article/details/80848422

1. Longest Valid Parentheses

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 “()()”

这个题我下面要讨论的方法是有问题的（时间超时），但是因为这种方法引发一系列问题值得思考。首先笔者定义 $F [i, j]$ 为当前i到j位置的合法括号的长度，那么状态转移方程为：

F[i,j]=F[i+1,j-1]+2                 if F[i]=='(' and F[j] ==')'
      =max(a,b)
 a=max(F[i,j],F[i,i+k-1]+F[i+k,j])  i<i+k<j
 b=max(F[i,j],F[i,j-k]+F[j-k+1,j])  i<j-k<j

当我写出这个状态转移方程的时候，我没有畏惧反而还真去写代码了，代码如下所示：

class Solution {
public:
      int longestValidParentheses(string s){
        vector<vector<int>> F(s.size());
        int ans=0;
        for(int i=0;i<s.size();++i)
            F[i].resize(s.size(),0);
        for(int i=0;i+1<s.size();++i)
            if(s[i]=='(' && s[i+1] == ')')
                F[i][i+1]=2;
        
        for(int len=4;len<=s.size();len+=2)
		    //i的范围难以设定
            for(int i=0;i<s.size()+1-len;++i)
		        //是否需要加F[i+1][len-1+i-1] != 0
                if(F[i+1][len-1+i-1] != 0 && s[i] =='(' && s[len-1+i] == ')')
                    F[i][len-1+i]=F[i+1][len-1+i-1]+2;
                else{
                    for( int k=1;k<s.size()-i-1;++k)
                        if(F[i+k+1][len-1+i] != 0 && F[i][i+k]!=0)
                            F[i][len-1+i]=max(F[i][len-1+i],F[i+k+1][len-1+i]+F[i][i+k]);
                    for( int k=1;k<len-1;++k)
                        if(F[i][len-1+i-k] != 0 && F[len+i-k][len-1+i] !=0 )
                            F[i][len-1+i]=max(F[i][len-1+i],F[i][len-1+i-k]+F[len+i-k][len-1+i]);
                }   
    
        for(int i=0;i<F.size();++i){
            for(int j=0;j<F[0].size();++j){
                if(F[i][j]>ans)
                    ans=F[i][j];
            }
        }
        return ans;
    }
};

这里写图片描述
　　首先提前说下，该代码因为时长问题没有AC，但理论上该算法是对的。当然我并不是想说复杂的算法和糟糕的时间复杂度值得学习，相反在确定i的循环范围时，有两个思路：

//举列子
for(i=?;i<n;)
   if   statement1
	   F[i-3]=xx;
   else if  statement2
	   F[i-2]=xx;
   else statement3
	   F[i+1]=xx;

每个statement对i都有限制，可以综合三种限制放在for(;;)循环中。
在每个if语句下面单独加上i的限制。

笔者在上面的DP实现过程中，遇到了上面的问题，一开始想着代码简洁选择了第一种实现方式，但这是错的。原因是因为会让i漏掉一些情况，相反应该选择第二种，逻辑上简单，实现也简单。第二个遇到的问题是在状态转移的时候，是否要判断前一个状态的合法性。
　　这个问题可是DP编程实现的一个比较重要的问题，如果从定义出发，这个状态本身就是有效状态下的值，所以必须加。但是回想有些题确实也没有加啊，如果一个状态非法，经过转移的下一个状态也非法。但是这个题显然不同， $F [i, j]$ 为当前i到j位置的合法括号的长度。
　　综上所述，该题笔者上面版本的DP思考上与实现上都有些陷阱，然后时间复杂度为 $O(n^3)$ ，光荣超时。