20.Vaild-Parentheses

20.Vaild-Parentheses

题目描述

判断括号是不是匹配

思路

使用栈，遍历输入字符串
如果当前字符为左半边括号时，则将其压入栈中
如果遇到右半边括号时，分类讨论：
1）如栈不为空且为对应的左半边括号，则取出栈顶元素，继续循环

2）若此时栈为空，则直接返回 false

3）若不为对应的左半边括号，反之返回 false

代码

class Solution {
public:
    bool isValid(string s) {
        stack<char> p;
        for(decltype(s.size()) i = 0;i<s.size();i++){
            if(s[i]=='('||s[i]=='['||s[i]=='{'){
                p.push(s[i]);
            }
            else{
                if(p.empty()) //栈得不为空
                    return false;
                char t=p.top();
                p.pop();
                if((t=='('&&s[i]!=')')||(t=='['&&s[i]!=']')||(t=='{'&&s[i]!='}'))
                    return false;
            }
        }
        if (!p.empty()) //栈得为空
            return false;
        return true;
    }
};

改进

• 分类讨论，考虑多种情况
• 用map记录括号的对应关系
  为了快速判断括号的类型，我们可以使用哈希映射（HashMap）存储每一种括号。哈希映射的键为右括号，值为相同类型的左括号。

  unordered_map<char, char> pairs = {
              {')', '('},
              {']', '['},
              {'}', '{'}
          };
  

• 注意到有效字符串的长度一定为偶数，因此如果字符串的长度为奇数，我们可以直接返回 false ，省去后续的遍历判断过程。

O（1）空间

基本思路是改参数，将参数作为我们的栈。 随着我们不断遍历， s 慢慢变成了一个栈。

class Solution {
public:
    bool isValid(string s) {
        int top = -1;
        for(int i =0;i<s.length();++i){
            if(top<0 || !isMatch(s[top], s[i])){
                ++top;
                s[top] = s[i];
            }else{
                --top;
            }
        }
        return top == -1;
    }
    bool isMatch(char c1, char c2){
        if(c1 == '(' && c2 == ')') return true;
        if(c1 == '[' && c2 == ']') return true;
        if(c1 == '{' && c2 == '}') return true;
        return false;
    }
};

正则比配

我们不断通过消除 ‘[]’ ， ‘()’, ‘{}’ ，最后判断剩下的是否是空串即可，就像开心消消乐一样。
python解法

class Solution:
     def isValid(self, s):

        while '[]' in s or '()' in s or '{}' in s:
            s = s.replace('[]','').replace('()','').replace('{}','')
        return not len(s)

c++的正则表达式解法：超出时间限制
c++还是用比较底层的东西比较合适

class Solution {
public:
    bool isValid(string s) {
        if(s.size()%2!=0)
            return false;
        while(regex_search(s,regex("\\[\\]"))==1||regex_search(s,regex("\\(\\)"))==1||regex_search(s,regex("\\{\\}"))==1){
            s = regex_replace(s, regex("\\[\\]"), "");
            s = regex_replace(s, regex("\\(\\)"), "");
            s = regex_replace(s, regex("\\{\\}"), "");
        }
        if(s.empty())
            return true;
        else
            return false;
    }
};

扩展题

方法一：动态规划
方法二：栈

思路

具体做法是我们始终保持栈底元素为当前已经遍历过的元素中「最后一个没有被匹配的右括号的下标」，这样的做法主要是考虑了边界条件的处理，栈里其他元素维护左括号的下标：

• 对于遇到的每个 \text{‘(’}‘(’ ，我们将它的下标放入栈中
• 对于遇到的每个 \text{‘)’}‘)’ ，我们先弹出栈顶元素表示匹配了当前右括号：
  • 如果栈为空，说明当前的右括号为没有被匹配的右括号，我们将其下标放入栈中来更新我们之前提到的「最后一个没有被匹配的右括号的下标」
  • 如果栈不为空，当前右括号的下标减去栈顶元素即为「以该右括号为结尾的最长有效括号的长度」

需要注意的是，如果一开始栈为空，第一个字符为左括号的时候我们会将其放入栈中，这样就不满足提及的「最后一个没有被匹配的右括号的下标」，为了保持统一，我们在一开始的时候往栈中放入一个值为 -1 的元素。

方法三：不需要额外的空间

class Solution {
public:
    int longestValidParentheses(string s) {
        int max=0;
        stack<int>p;
        p.push(-1);//初始情况
        for(int i=0;i<s.size();i++){
            if(s[i]=='('){
                p.push(i);
            }
            else{
                p.pop();
                if(p.empty()){
                    p.push(i);
                }
                else{
                    max=(i-p.top())>max?(i-p.top()):max;
                }
            }
        }
        return max;
    }
};