题目:
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.
链接: http://leetcode.com/problems/longest-valid-parentheses/
题解:
一开始想要尝试跟Valid Parentheses类似的解法,就是维护一个leftCount,一个rightCount,当leftCount < rightCount的时候清零,当leftCount = rightCount时,尝试更新max,结果出错。后来看到曹神的解法,才发现还应该从字符串尾部向前再来一遍。
下面是解法,two passes, Time Complexity - O(n), Space Complexity - O(1)。
public class Solution { public int longestValidParentheses(String s) { //if left parentheses count > right parentheses count, case always valid if(s == null || s.length() == 0) return 0; int start = -1, depth = 0, max = 0; for(int i = 0; i < s.length(); i++) { if(s.charAt(i) == '(') depth++; else { depth--; if(depth < 0) { start = i; depth = 0; } if(depth == 0) max = Math.max(max, i - start); } } depth = 0; start = s.length(); for(int i = s.length() - 1; i >= 0; i--) { //if right parentheses count > left parentheses count, case always valid if(s.charAt(i) == ')') depth++; else { depth--; if(depth < 0) { start = i; depth = 0; } if(depth == 0) max = Math.max(max, start - i); } } return max; } }
还有一种解法是one pass, 方法是维护一个stack以及一个start index,遇到左括号入栈,遇到右括号出栈,当stack为空时说明左右括号平衡,计算i 与 start的距离, 否则左括号数目>右括号数目,计算i 与当前栈顶元素距离。 有小trick可以设置start = -1,这样代码里计算距离就可以不用 + 1了。还可以稍微简化一下,不过逻辑下面更清楚。
Time Complexity - O(n), Space Complexity - O(n)。
public class Solution { public int longestValidParentheses(String s) { if(s == null || s.length() == 0) return 0; Stack<Integer> stack = new Stack<>(); int start = 0, max = 0; for(int i = 0; i < s.length(); i++) { if(s.charAt(i) == '(') //record index of each '(' stack.push(i); else { if(stack.isEmpty()) //try to find first '(' start = i + 1; else { stack.pop(); if(stack.isEmpty()) //left num = right num max = Math.max(max, i - start + 1); else //left > right, cal max with current top element in stack max = Math.max(max, i - stack.peek()); } } } return max; } }
二刷:
可以用三种方法来做:
- 一种是曹神的方法,使用类似valid parentheses的方法。
- 维护一个depth,一个count。
- 从左向右遍历时并且当char == '('时,depth++,否则char = ')',depth--,这时候我们count++,因为找到了一对valid parenthese
- 当depth == 0的时候,左右括号平衡,可以尝试更新max, max = Math.max(max, count * 2)
- 接下来判断depth是否小于0,小于0的话depth = 0, count = 0,我们从头开始计算。
- 左右各自遍历一遍。从右向左遍历是为了计算类似于"()(()()"这种情况,这时depth always > 0,没办法得到max = 4的结论。
- 一种是一维DP,分好几种情况,画一个decision tree会比较清楚逻辑。
- 维护一个数组max[], 其中max[i]代表以s.charAt(i)结尾的longest valid parentheses的长度。我们考虑接下来集中情况。
- max[0] = 0,因为此时不能组成"()"。所以我们可以直接从 i = 1开始遍历
- 当前字符是'(', max[i] = 0,因为valid parentheses不能以'('结尾 否则,当前字符等于')',这时候继续判断几种情况
- s.charAt(i - 1) = '(',正好可以组成一对括号。
- 当 i - 2 >= 0,max[i] = max[i - 2] + 2
- 当 i - 2 < 0, max[i] = 2
- 否则s.charAt(i - 1) = ')',此时我们也是继续进行判断
- 此时我们要求出i关于max[i - 1]对称的字符,就是 i - max[i - 1] - 1
- 假如i - max[i - 1] - 1 >= 0,并且 s.charAt(i - max[i - 1] - 1) == '('
- 此时表示从i - max[i - 1] - 1到i这一段都合理,所以这一部分等于max[i - 1] + 2, 我们要继续判断 i - max[i - 1] - 2
- 当i - max[i - 1] - 2 >= 0, 则 max[i] = max[i - 1] + 2 + max[i - max[i - 1] - 2]
- 否则max[i] = max[i - 1] + 2
- 此时表示从i - max[i - 1] - 1到i这一段都合理,所以这一部分等于max[i - 1] + 2, 我们要继续判断 i - max[i - 1] - 2
- 否则max[i] = 0,我们不改变什么
- 假如i - max[i - 1] - 1 >= 0,并且 s.charAt(i - max[i - 1] - 1) == '('
- 此时我们要求出i关于max[i - 1]对称的字符,就是 i - max[i - 1] - 1
- s.charAt(i - 1) = '(',正好可以组成一对括号。
- 在开头维护一个res = 0, 每次计算完max[i]之后尝试更新这个res,最后返回的也是这个res.
- 其实还可以继续简化,留给三刷了
- 一种是利用一个stack来计算,这个留给三刷了,也是O(n)和O(n)
Java:
Time Complexity - O(n), Space Complexity - O(1)
public class Solution { public int longestValidParentheses(String s) { if (s == null || s.length() == 0) { return 0; } int count = 0, max = 0, depth = 0; for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); if (c == '(') { depth++; } else { depth--; count++; if (depth == 0) { max = Math.max(max, count * 2); } if (depth < 0) { depth = 0; count = 0; } } } depth = 0; count = 0; for (int i = s.length() - 1; i >= 0; i--) { char c = s.charAt(i); if (c == ')') { depth++; } else { depth--; count++; if (depth == 0) { max = Math.max(max, count * 2); } if (depth < 0) { depth = 0; count = 0; } } } return max; } }
DP - Time Complexity - O(n), Space Complexity - O(n)
public class Solution { public int longestValidParentheses(String s) { if (s == null || s.length() == 0) { return 0; } int[] max = new int[s.length()]; // max[i] contains longest valid parentheses end at i int res = 0; for (int i = 1; i < max.length; i++) { char c = s.charAt(i); if (c == '(') { max[i] = 0; } else { // c = ')' if (s.charAt(i - 1) == '(') { max[i] = i - 2 >= 0 ? max[i - 2] + 2 : 2; } else { if (i - max[i - 1] - 1 >= 0 && s.charAt(i - max[i - 1] - 1) == '(') { max[i] = max[i - 1] + 2 + (i - max[i - 1] - 2 >= 0 ? max[i - max[i - 1] - 2] : 0); } } } res = Math.max(max[i], res); } return res; } }
题外话:
1-20-2016
DP一直学得不好, divide and conquer也学得不好,需要多练习多思考。 像Matrix multiply, counting inversion,closest pair,merge sort之类的,一定要多多练习。还有Weighted quick union with path compression, run-length coding, Huffman Tree等等。
三刷:
还是使用曹神的方法,赞曹神思路清晰。
Java:
public class Solution { public int longestValidParentheses(String s) { if (s == null || s.length() == 0) return 0; int max = 0, count = 0, start = 0, len = s.length(); for (int i = 0; i < len; i++) { if (s.charAt(i) == '(') count++; else count--; if (count == 0) max = Math.max(max, i - start + 1); if (count < 0) { count = 0; start = i + 1; } } start = len - 1; count = 0; for (int i = len - 1; i >= 0; i--) { if (s.charAt(i) == ')') count++; else count--; if (count == 0) max = Math.max(max, start - i + 1); if (count < 0) { count = 0; start = i - 1; } } return max; } }
Reference:
http://weibo.com/cpcs 曹神微博
http://www.cnblogs.com/springfor/p/3869495.html 小莹子
https://leetcode.com/discuss/9156/my-solution-using-one-stack-in-one-pass
https://leetcode.com/discuss/21549/simple-java-solution-o-n-time-one-stack
https://leetcode.com/discuss/8092/my-dp-o-n-solution-without-using-stack
https://leetcode.com/discuss/7609/my-o-n-solution-using-a-stack