LeetCode之“动态规划”：Valid Parentheses && Longest Valid Parentheses

　 1. Valid Parentheses

　　题目链接

　　题目要求：

　　Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

　　The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]" are not.

　　这个题用‘栈’这种数据结构解决是比较方便的。程序如下：

class Solution {
public:
    bool isValidPar(char left, char right)
    {
        if (left == '(' && right == ')')
            return true;
        if (left == '[' && right == ']')
            return true;
        if (left == '{' && right == '}')
            return true;
    
        return false;
    }
    
    bool isValid(string s) {
        int sz = s.size();
        stack<char> left;
        for(int i = 0; i < sz; i++)
        {
            char c = s[i];
            if(c == '(' || c == '[' || c == '{')
                left.push(s[i]);
            else
            {
                if(left.size() == 0)
                    return false;
                    
                char top = left.top();
                if(!isValidPar(top, c))
                    return false;
                    
                left.pop();
            }
        }
        
        return left.size() == 0;
    }
};

　 2. 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.

　　此文的动态规划解法参考自一博文：

　 1. 状态

　　DP[i]：以s[i-1]为结尾的longest valid parentheses substring的长度。　　

　 2. 通项公式

　　s[i] = '('：
　　DP[i] = 0

　　s[i] = ')'：找i前一个字符的最长括号串DP[i]的前一个字符 j = i-2-DP[i-1]
　　DP[i] = DP[i-1] + 2 + DP[j]，如果j >=0，且s[j] = '('
　　DP[i] = 0，如果j<0，或s[j] = ')'

　　......... (     x    x    x    x   )
          　　j                     i-2 i-1

　　证明：不存在j' < j，且s[j' : i]为valid parentheses substring。
　　假如存在这样的j'，则s[j'+1 : i-1]也valid。那么对于i-1来说：
　　(    x    x    x    x    x
　　j' j'+1                  i-1
　　这种情况下，i-1是不可能有比S[j'+1 : i-1]更长的valid parentheses substring的。

　 3. 计算方向

　　显然自左向右，且DP[0] = 0

 　　具体代码如下：

class Solution {
public:
    int longestValidParentheses(string s) {
        int sz = s.size();
        if(sz < 2)
            return 0;

        int maxLen = 0;
        vector<int> dp(sz + 1, 0);
        for(int i = 1; i < sz + 1; i++)
        {
            int j = i - 2 - dp[i - 1];
            if(s[i - 1] == '(' || j < 0 || s[j] == ')')
                dp[i] = 0;
            else
            {
                dp[i] = dp[i - 1] + 2 + dp[j];
                maxLen = max(maxLen, dp[i]);
            }
        }
        
        return maxLen;
    }
};