[LeetCode][JavaScript]Longest Valid Parentheses

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.

 https://leetcode.com/problems/longest-valid-parentheses/

 

 

---

 

没用动态规划，就用了个栈...

举个栗子：)(()())( 

栈里的数字就是weight啦，用个栈一顿倒来倒去之后，就变成了一个数列。

就好像这样-1 2 10 8 2 -1 12 8 -1 2 4

问题就转换成了合并数列中的正数，最大的就是结果。

啊啊啊，这样解好麻烦，写了好多行，好伤心，老老实实dp就好了嘛。

 

/**
 * @param {string} s
 * @return {number}
 */
var longestValidParentheses = function(s) { 
    var stack = [];
    for(var i = 0; i < s.length; i++){
        if(s[i] === '('){
            stack.push({
                value : '(',
                weight : -1
            });
        }else{
            var targetIndex = -1;
            for(var j = stack.length - 1; j >= 0; j--){
                if(stack[j].value === '('){
                    targetIndex = j;
                    break;
                }
            }
            
            if(targetIndex === -1){
                stack.push({
                    value : ')',
                    weight : -1
                });
            }else{
                var merge = null;
                while(stack.length - targetIndex - 1){
                    var tmp = stack.pop();
                    if(merge === null){
                        merge = tmp;
                    }else{
                        merge.value += tmp.value;
                        merge.weight += tmp.weight;
                    }
                }
                stack.pop();
                if(merge === null){
                    stack.push({
                        value : '()',
                        weight : 2
                    });
                }else{
                    stack.push({
                        value : "(" + merge.value + ")",
                        weight : merge.weight + 2
                    });
                }
            }
        }
    }
    
    var max = 0;
    var currMax = 0;
    for(i = 0; i < stack.length; i++){
        var curr = stack[i];
        if(curr.weight === -1){
            if(currMax > max){
                max = currMax;
            }
            currMax = 0;
        }else{
            currMax += curr.weight;
        }    
    }
    if(currMax > max){
        max = currMax;
    }
    return max;
};