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 = ; i < sz; i++)
         {
             char c = s[i];
             if(c == '(' || c == '[' || c == '{')
                 left.push(s[i]);
             else
             {
                 if(left.size() == )
                     return false;

                 char top = left.top();
                 if(!isValidPar(top, c))
                     return false;

                 left.pop();
             }
         }

         return left.size() == ;
     }
 };

　 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 < )
             return ;

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

         return maxLen;
     }
 };