Leetcode Algorithm 032. Longest Valid Parentheses

Leetcode Algorithm 032. Longest Valid Parentheses

Longest Valid Parentheses

给定一个只含有

'('

和

')'

的字符串，求出符合括号匹配要求的最长子串（不是子序列）。

解题思路

一看到括号匹配马上想到栈。

一看到最长字串马上想到动态规划。

结合栈和动态规划，可以召唤这道题的答案。

栈可以解决括号匹配的问题。遇到左括号

'('

压栈，遇到右括号

')'

出栈。

对于

"(()"

，可以匹配一组括号。

对于

")()())"

，可以匹配两组括号。

对于

"()(()"

，可以匹配两组括号。

对于

"()(())"

，可以匹配三组括号。

那么问题来了，括号匹配完成的是一个最长子序列的问题，但是要得到最长子串的话并不容易。

对于

"(()"

，最长字串包含一组括号。

对于

")()())"

，最长字串包含两组括号，两组括号相连。

对于

"()(()"

，最长字串包含一组括号，因为有两组括号被一个左括号

'('

相隔。

对于

"()(())"

，最长字串包含三组括号。

所以，在括号匹配时，我们需要计算当前位置的最长括号匹配子串的长度。

用

length[i]

来表示到字符串

s

的第

i

个位置的时候，最长括号匹配子串的长度，那么：

如果

s[i]

是左括号

'('

的话，没有匹配的括号，

length[i]=0

；

如果

s[i]

是右括号的话：

若栈为空， 则没有匹配的括号，

length[i]=0

若栈不为空，则可以匹配一组括号，

length[i]=2

。此时需要检查括号的相连性。相连也分两种情况：

(1) 内连： 如果

s[i-1]

是右括号的且匹配成功的话，

length[i]+=length[i-1]

，比如

"(())"

这种情况

(2) 外连：如果所匹配的左括号之前一个位置

k

有括号匹配成功，则

length[i]+=length[k]

，比如

"()(())"

这种情况，最后一个括号匹配时发现1号位置上有括号匹配成功。

所以，栈不为空时，动态转移方程就是：

length[i] = length[i-1] + length[k] + 2

。

为了能正确找出

k

的位置，在括号匹配压栈时，需要压入左括号的下标。

样例1：

"(()"

index	0	1	2
s	(	(	)
stack	0	0,1	0
length	0	0	2

*2号的右括号匹配了1号的左括号，

length[1]=0

， 没有内连，1号括号的前一个是

length[0]=0

，也没有外联。

样例2：

")()())"

index	0	1	2	3	4	5
s	)	(	)	(	)	)
stack	-	1	-	3	-	-
length	0	0	2	0	4	0

样例3：

"()(()"

index	0	1	2	3	4
s	(	)	(	(	)
stack	0	-	2	2,3	2
length	0	2	0	0	2

*4号的右括号匹配了3号的左括号，

length[3]=0

， 没有内连，3号括号的前一个是

length[2]=0

，也没有外联。

样例3：

"()(()"

index	0	1	2	3	4	5
s	(	)	(	(	)	)
stack	0	-	2	2,3	2	-
length	0	2	0	0	2	6

*5号的右括号匹配了2号的左括号，

length[4]=2

， 有内连，2号括号的前一个是

length[1]=2

，也有外联，故

length[5] = length[4]+length[1]+2

最后的答案是maxi(s[i])。

代码

#include<iostream>
#include<stack>
#include<vector>

using namespace std;

class Solution {
public:
int longestValidParentheses(string s) {
stack<int> stk;
int n = s.size();
vector<int> length(n, 0);
int max_length = 0;

for (int i = 0; i < n; i++) {
if (s[i] == '(') {
stk.push(i);
} else {
if (!stk.empty()) {
int top = stk.top();
stk.pop();
length[i] = length[i - 1] + 2;

if (top - 1 >= 0)
length[i] += length[top - 1];
max_length = max(max_length, length[i]);
}
}
}
return max_length;
}
};

测试样例

int main() {
Solution s;
cout << s.longestValidParentheses("(()") << endl;
cout << s.longestValidParentheses(")()())") << endl;
cout << s.longestValidParentheses("()(()") << endl;
cout << s.longestValidParentheses("()(())") << endl;

return 0;
}

输出

2
4
2
6