LeetCode | 32. Longest Valid Parentheses——最长有效括号匹配长度

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.

解法一：用两个指针对下标进行枚举，用一个函数判断这个子串是否有效，并比较长度和最大值。用栈实现。217/229 Passed，超时。

class Solution {
public:
bool judge(string str)
{
stack<char> s;
int len = str.length();
for(int i=0;i<len;i++)
{
if(str[i] == '(')
s.push(str[i]);
else
{
if(s.empty())
return false;
if(s.top() == '(')
s.pop();
else
return false;
}
}
if(s.empty())
return true;

return false;
}

int longestValidParentheses(string s)
{
int len = s.length();
int mmax = 0;
for(int i=0;i<len;i++)
{
for(int j=i+1;j<len;j+=2)       //长度肯定是偶数
{
string tmp = s.substr(i,j-i+1);
//cout<<tmp<<endl;
if(judge(tmp))
{
if(j-i+1 > mmax)
mmax = j-i+1;
}
}
}
return mmax;
}
};

解法二：二维动态规划。对子串长度进行动规，按理说时间复杂度够，但是交上去之后内存爆炸。

class Solution {
public:

int dp[1000][1000];//dp[i][j]=1 表示 i 到 j 是有效的

int longestValidParentheses(string s)
{
int len = s.length();
int mmax = 0;
int dp_len = 0;     //当前动归的子串长度
if(len==0 || len==1)
{
return 0;
}

//初始化
for(int i=0;i<len;i++)
dp[i][i] = 0;
for(int i=0;i<len-1;i++)
{
if(s[i]=='(' && s[i+1]==')')
{
dp[i][i+1] = 1;
mmax = 2;
}
}

for(dp_len=4;dp_len<=len;dp_len+=2)
{
for(int i=0;i+dp_len-1<len;i++)
{
int flag = 0;
int j = i+dp_len-1;     //动归dp[i][j];
if(dp[i+1][j-1] == 1)
{
if(s[i]=='(' && s[j]==')')
{
dp[i][j] = 1; flag = 1;     //当前子串已经为1，不用再找下面的
}
}
if(flag == 0)
{
if(dp[i][j-2] == 1)
{
if(s[j-1]=='(' && s[j]==')')
{
dp[i][j] = 1; flag = 1;
}
}
}
if(flag == 0)
dp[i][j] = 0;
else
{
if(dp_len > mmax)
mmax = dp_len;
}

}
}

return mmax;
}
};

解法三：一维动态规划，时间复杂度O(n)

dp[i] 表示以 i 为结尾的子串的有效括号匹配长度

若s[i]和s[i-1]能够匹配，那么dp[i] = dp[i-2]+2;

若不能匹配，考虑dp[i-1]，即以s[i-1]为结尾的最大匹配长度，然后看s[i]与s[i-dp[i-1]-1]是否能匹配。若能匹配，再加上最前面的一段。

class Solution {
public:

int dp[100000];//dp[i] 表示以 i 为结尾的子串的有效括号匹配长度

int longestValidParentheses(string s)
{
int len = s.length();
int mmax = 0;
if(len==0 || len==1)
return 0;

//初始化
dp[0] = 0;
for(int i=1;i<len;i++)
{
if(s[i]==')' && s[i-1]=='(')
{
dp[i] = 2; mmax = 2;
}
else
dp[i] = 0;
}

if(len >= 4)
{
for(int i=3;i<len;i++)
{
dp[i] = 0;
if(s[i] == '(')
continue;
else
{
if(s[i-1] == '(')
dp[i] = dp[i-2]+2;
else if(dp[i-1] < i)    //前面还可以匹配
{
if(s[i-dp[i-1]-1] == '(')
{
dp[i] = dp[i-1]+2;
if(i-dp[i-1]-2 >= 0)
dp[i] += dp[i-dp[i-1]-2];
}
}
}
}
}

for(int i=0;i<len;i++)
{
if(dp[i] > mmax)
mmax = dp[i];
}

return mmax;
}

};