方法1:
使用栈
struct P{
int s,e;
P(int l,int r):s(l),e(r){}
};
class Solution {
public:
int longestValidParentheses(string s) {
stack<int> st;
stack<P> vs;
stack<P> ans;
int len=s.size();
for(int i=0;i<len;i++)
{
if(s[i]=='(')
st.push(i);
else
{
if(!st.empty())
{
P p(st.top(),i);
vs.push(p);
st.pop();
}
}
}
while(!vs.empty())
{
P t=vs.top();
vs.pop();
while(!vs.empty())
{
P p=vs.top();
vs.pop();
if(p.e+1==t.s)
t.s=p.s;
else if(p.e+1<t.s)
{
vs.push(p);
break;
}
}
ans.push(t);
}
int max_len=0;
while(!ans.empty())
{
P p=ans.top();
ans.pop();
len=p.e-p.s+1;
max_len=max_len>len?max_len:len;
}
return max_len;
}
};
方法2:
使用一维动态规划逆向求解
class Solution {
public:
int longestValidParentheses(string s) {
int n=s.size();
int dp[n];
memset(dp,0,sizeof(dp));
int i,j,mx=0;
if(n<2)
return 0;
for(i=n-2;i>=0;i--)
{
if(s[i]=='(')
{
j=i+1+dp[i+1];
if(j<n&&s[j]==')')
{
dp[i]=dp[i+1]+2;
if(j+1<n)
dp[i]+=dp[j+1];
}
mx=max(mx,dp[i]);
}
}
return mx;
}
};