[LeetCode] 678. Valid Parenthesis String

Given a string s containing only three types of characters: '(', ')' and '*', return true if s is valid.

The following rules define a valid string:

• Any left parenthesis '(' must have a corresponding right parenthesis ')'.
• Any right parenthesis ')' must have a corresponding left parenthesis '('.
• Left parenthesis '(' must go before the corresponding right parenthesis ')'.
• '*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string "".

Example 1:

Input: s = "()"
Output: true

Example 2:

Input: s = "(*)"
Output: true

Example 3:

Input: s = "(*))"
Output: true

Constraints:

• 1 <= s.length <= 100
• s[i] is '(', ')' or '*'.

有效的括号字符串。

给你一个只包含三种字符的字符串，支持的字符类型分别是 '('、')' 和 '*'。请你检验这个字符串是否为有效字符串，如果是有效字符串返回 true 。

有效字符串符合如下规则：

任何左括号 '(' 必须有相应的右括号 ')'。
任何右括号 ')' 必须有相应的左括号 '(' 。
左括号 '(' 必须在对应的右括号之前 ')'。
'*' 可以被视为单个右括号 ')' ，或单个左括号 '(' ，或一个空字符串。
一个空字符串也被视为有效字符串。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/valid-parenthesis-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题意是给一个字符串，里面有左括号右括号和星号，请判断 input 字符串是否是一个合法的括号组合。其中星号是一个通配符，可以表示左括号右括号或者星号。做这个题之前需要先复习一下20题。这道题我提供三种做法，第一种扫描两遍，第二种扫描一遍，第三种会用到栈。

首先是扫描两遍的做法。第一遍从左往右，第二遍从右往左。第一遍扫描的时候，把星号当做左括号，所以遇到左括号和星号的时候就 left++，遇到右括号就 left--；过程中只要 left 小于 0 就 return false，说明右括号多而且是星号没法补救的。第一遍扫描完毕之后如果 left == 0 则直接 return true，因为左括号 + 星号可以和右括号互相抵消。如果 left 大于0 也不用担心，因为这里面应该是存在一些星号的。

第二遍扫描的时候是从右往左，此时把星号当做右括号，如果看到右括号或者星号就 right++，看到左括号就 right--；跟第一遍一样，过程中只要 right 小于 0 了就 return false，说明左括号多到无法补救。遍历结束则 return true。

一个疑问：如果第一遍里面只是左括号比较多，left 不也是大于 0 吗？没问题，第二遍扫描的时候，这种 case 会被抓出来（因为 right 会小于 0 了）从而 return false。

时间O(n)

空间O(1)

Java实现

class Solution {
    public boolean checkValidString(String s) {
        int left = 0;
        int right = 0;
        int n = s.length();
        // scan from left to right
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == '(' || s.charAt(i) == '*') {
                left++;
            } else {
                left--;
            }
            if (left < 0) {
                return false;
            }
        }
        if (left == 0) {
            return true;
        }

        // scan from right to left
        for (int i = n - 1; i >= 0; i--) {
            if (s.charAt(i) == ')' || s.charAt(i) == '*') {
                right++;
            } else {
                right--;
            }
            if (right < 0) {
                return false;
            }
        }
        return true;
    }
}

 

JavaScript实现

/**
 * @param {string} s
 * @return {boolean}
 */
var checkValidString = function(s) {
    let left = 0;
    let right = 0;
    let len = s.length;
    for (let i = 0; i < len; i++) {
        if (s.charAt(i) == '(' || s.charAt(i) == '*') {
            left++;
        } else {
            left--;
        }
        if (left < 0) {
            return false;
        }
    }
    if (left == 0) {
        return true;
    }

    for (let i = len - 1; i >= 0; i--) {
        if (s.charAt(i) == ')' || s.charAt(i) == '*') {
            right++;
        } else {
            right--;
        }
        if (right < 0) {
            return false;
        }
    }
    return true;
};

 

接下来是扫描一遍的做法。这里我们设置两个变量cmax和cmin，代表需要被match的左括号的上限和下限。

当遇到一个左括号的时候，cmax和cmin都需要++，因为你需要为这个左括号找一个配对

当遇到一个右括号的时候，自然是cmax--，cmin也需要--，但是如果cmin小于0了，说明右括号更多了，此时我们为了不让他小于0，我们取的是0和cmin的较大值

当遇到一个星号的时候，因为他是通配符，所以如果当做左括号的话，cmax就++，如果当做右括号的话，cmin就--，因为他可以去抵消一个左括号

最后判断的时候，如果cmax小于0就return false，因为cmax只有在遇到右括号的时候才--，说明右括号多到无法被抵消。

时间O(n)

空间O(1)

Java实现

class Solution {
    public boolean checkValidString(String s) {
        int cmin = 0;
        int cmax = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '(') {
                cmax++;
                cmin++;
            } else if (c == ')') {
                cmax--;
                cmin = Math.max(cmin - 1, 0);
            } else {
                cmax++;
                cmin = Math.max(cmin - 1, 0);
            }
            if (cmax < 0) {
                return false;
            }
        }
        return cmin == 0;
    }
}

 

第三种解法用到栈。这里我们需要两个栈，一个记录左括号的 index，一个记录星号的 index，这里我们分别叫做 stack1 和 stack2。

• 遇到左括号，把 index 入栈 stack1
• 遇到右括号，
  • 如果 stack1 不为空，弹出栈顶元素，说明有一个左右括号的配对
  • 如果 stack1 为空，看看 stack2 是否为空 - 是否有星号，如有，则用星号抵消左括号
  • 如果此时 stack1 和 stack2 都为空，return false
• 遇到星号，放入 stack2

此时我们可以处理所有左括号，但是 stack1 和 stack2 可能不为空，此时我们需要判断 stack2 里面的星号是否能抵消 stack1 里剩余未配对的括号。注意这里配对的原则是如果括号的 index 大于星号的 index，说明这个括号是不能被抵消的，因为他出现在了一个星号之后，星号只能抵消之前的括号。

时间O(n)

空间O(n)

Java实现

class Solution {
    public boolean checkValidString(String s) {
        Stack<Integer> operators = new Stack<>();
        Stack<Integer> stars = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            // 遇到左括号
            if (s.charAt(i) == '(') {
                operators.push(i);
            }
            // 遇到右括号
            else if (s.charAt(i) == ')') {
                // 如果有左括号就抵消
                if (operators.size() > 0) {
                    operators.pop();
                }
                // 如果有星号就抵消
                else if (stars.size() > 0) {
                    stars.pop();
                } else {
                    return false;
                }
            }
            // 星号
            else {
                stars.push(i);
            }
        }

        while (operators.size() > 0 && stars.size() > 0) {
            if (operators.peek() > stars.peek()) {
                return false;
            }
            operators.pop();
            stars.pop();
        }
        return operators.size() == 0;
    }
}

 

相关题目

20. Valid Parentheses

678. Valid Parenthesis String

1111. Maximum Nesting Depth of Two Valid Parentheses Strings

921. Minimum Add to Make Parentheses Valid

1541. Minimum Insertions to Balance a Parentheses String

LeetCode 题目总结