leetcode 括号组合题目 20 是否是有效括号 32 最大有效括号 301 去掉无效括号

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

判断一个字符串是否是有效的括号组合

思路，依次将这些字符入栈，判断栈顶元素与当前元素是否是对应上的，是则pop，不是则入栈，到最后判断栈是否为空。

 class Solution {
 public:
     bool isValid(string s) {
         stack<char> result;
         int n=s.size();
         if(n==0) return true;
      for(int i=0;i
             {
                 if(result.empty())
                     result.push(s[i]);
                 else if(result.top()=='('&&s[i]==')'||
                       result.top()=='['&&s[i]==']'||
                       result.top()=='{'&&s[i]=='}')
                         result.pop();
                 else
                     result.push(s[i]);

             }
             return result.empty();
     }
 };

别人的思路：

这种方法能够更快的判断不符合条件的字符串，不需要将字符串遍历完成。

 class Solution {
 public:
     bool isValid(string s) {
         stack<char> paren;
         for (char& c : s) {
             switch (c) {
                 case '(':
                 case '{':
                 case '[': paren.push(c); break;
                 case ')': if (paren.empty() || paren.top()!='(') return false; else paren.pop(); break;
                 case '}': if (paren.empty() || paren.top()!='{') return false; else paren.pop(); break;
                 case ']': if (paren.empty() || paren.top()!='[') return false; else paren.pop(); break;
                 default: ; // pass
             }
         }
         return paren.empty() ;
     }
 };

注意：只要当前的字符是)}]三个的一个，如果不能与栈顶结合，那就说明这个字符串是错误的。比如下面的代码。

 class Solution {
 public:
     bool isValid(string s) {
         stack<char> result;
         for(auto & a:s){
             if(a=='(') result.push(')');
             else if(a=='{') result.push('}');
             else if(a=='[')  result.push(']');
             else if(result.empty()||result.top()!=a)//这里直接出栈判断
                 return false;
             else result.pop();
         }
         return result.empty();
     }
 s and s[i−1]=‘(’, i.e. string looks like ‘‘.......()"⇒  dp[i]=dp[i−2]+2  We do so because the ending "()" portion is a valid substring anyhow and leads to an increment of 2 in the length of the just previous valid substring's length.
 s[i]=‘)’ and s[i−1]=‘)’, i.e. string looks like ‘‘.......))"⇒ if s[i−dp[i−1]−1]=‘(’ then  dp[i]=dp[i−1]+dp[i−dp[i−1]−2]+2  class Solution {
public:
    int longestValidParentheses(string s) {
        int n=s.size();
        if(n<=1) return 0;
        int res=0;
        vector dp(n,0);
        if(s[0]=='('&&s[1]==')')
        {
            dp[1]=2;
            res=2;
        }
        for(int i=2;i方法3 栈