leetcode1541. 平衡括号字符串的最少插入次数（Python3、c++）

leetcode1541. 平衡括号字符串的最少插入次数

给你一个括号字符串 s ，它只包含字符 '(' 和 ')' 。一个括号字符串被称为平衡的当它满足：

• 任何左括号 '(' 必须对应两个连续的右括号 '))' 。
• 左括号 '(' 必须在对应的连续两个右括号 '))' 之前。

比方说 "())"， "())(())))" 和 "(())())))" 都是平衡的， ")()"， "()))" 和 "(()))" 都是不平衡的。

你可以在任意位置插入字符 ‘(’ 和 ‘)’ 使字符串平衡。

请你返回让 s 平衡的最少插入次数。

示例 1：

输入：s = "(()))"
输出：1
解释：第二个左括号有与之匹配的两个右括号，但是第一个左括号只有一个右括号。我们需要在字符串结尾额外增加一个 ')' 使字符串变成平衡字符串 "(())))" 。

示例 2：

输入：s = "())"
输出：0
解释：字符串已经平衡了。

示例 3：

输入：s = "))())("
输出：3
解释：添加 '(' 去匹配最开头的 '))' ，然后添加 '))' 去匹配最后一个 '(' 。

示例 4：

输入：s = "(((((("
输出：12
解释：添加 12 个 ')' 得到平衡字符串。

示例 5：

输入：s = ")))))))"
输出：5
解释：在字符串开头添加 4 个 '(' 并在结尾添加 1 个 ')' ，字符串变成平衡字符串 "(((())))))))" 。

提示：

• 1 <= s.length <= 10^5
• s 只包含 '(' 和 ')' 。

---

方法一：栈

思路：

这种需要配对匹配的问题，通常可以使用栈来解决。

本题与普通的括号匹配的不同点在于，一个(需要与连续的两个)进行匹配，因此我们遍历字符串s的时候，遵循以下规则：

• 如果此时遍历到的字符为(，即s[i] = '('，那么直接入栈（只将左括号入栈）。
• 如果此时遍历到的字符为)，即s[i] = ')'，那么需要考虑s[i+1]的情况：
  • 如果s[i+1] = ')'那么说明为连续的两个右括号，这时如果栈中有元素，弹出栈顶元素，相当于一个())匹配成功；如果栈此时为空的，那么说明需要一个增加一个左括号才行，res ++。
  • 如果s[i+1] = '('那么说明此时只有一个右括号，首先需要增加另一个右括号，构成连续的两个右括号，res++；然后再与上面一致，判断栈的情况，如果栈有元素，则弹出栈顶元素，如果为空，则res ++。
• 遍历结束之后，如果栈中还有元素，即还有剩余的左括号没有配对，假设有n个，那么res += 2 * n

最后返回res即可。

代码：

Python3：

class Solution:
    def minInsertions(self, s: str) -> int:
        # 初始化栈，res
        stack = []
        res = 0
        i = 0
        n = len(s)
        # 开始遍历
        while i < n:
            # 如果是左括号，直接入栈
            if s[i] == '(':
                stack.append(s[i])
                i += 1
            else:
                # 如果连续两个右括号
                if i+1 < n and s[i+1] == ')':
                    if stack:
                        stack.pop()
                    else:
                        res += 1
                    i += 2
                # 如果只有一个右括号
                else:
                    if stack:
                        stack.pop()
                        res += 1
                    else:
                        res += 2
                    i += 1
        # 栈中剩余的左括号
        res += len(stack) * 2
        return res

cpp：

class Solution {
public:
    int minInsertions(string s) {
        // 初始化栈，res
        stack<char> stackk;
        int res = 0,i = 0;
        int n = s.size();
        // 开始遍历
        while (i < n){
            // 如果是左括号，直接入栈
            if (s[i] == '('){
                stackk.push(s[i]);
                i ++;
            }   
            else{
                // 如果连续两个右括号
                if (i+1 < n && s[i+1] == ')'){
                    if (!stackk.empty())
                        stackk.pop();
                    else
                        res ++;
                    i += 2;
                }
                // 如果只有一个右括号
                else{
                    if (!stackk.empty()){
                        stackk.pop();
                        res ++;
                    }                      
                    else
                        res +=2;
                    i ++;
                }       
            }        
        }          
        // 栈中剩余的左括号
        res += stackk.size() * 2;
        return res;
    }
};

结果：

方法二：优化

思路：

由上面的方法可知，栈中元素只可能是左括号，因此，我们不需要维护一个栈，我们只需要维护一个变量left来保存左括号的数量即可模拟栈。这样大大降低了空间复杂度。

代码：

Python3：

class Solution:
    def minInsertions(self, s: str) -> int:
        # 初始化left，res
        left = 0
        res = 0
        i = 0
        n = len(s)
        # 开始遍历
        while i < n:
            # 如果是左括号，直接left++
            if s[i] == '(':
                left += 1
                i += 1
            else:
                # 如果连续两个右括号
                if i+1 < n and s[i+1] == ')':
                    if left:
                        left -= 1
                    else:
                        res += 1
                    i += 2
                # 如果只有一个右括号
                else:
                    if left:
                        left -= 1
                        res += 1
                    else:
                        res += 2
                    i += 1
        # 栈中剩余的左括号
        res += left * 2
        return res

cpp：

class Solution {
public:
    int minInsertions(string s) {
        // 初始化left，res
        int res = 0,i = 0,left = 0;
        int n = s.size();
        // 开始遍历
        while (i < n){
            // 如果是左括号，直接++
            if (s[i] == '('){
                left ++;
                i ++;
            }   
            else{
                // 如果连续两个右括号
                if (i+1 < n && s[i+1] == ')'){
                    if (left)
                        left --;
                    else
                        res ++;
                    i += 2;
                }
                // 如果只有一个右括号
                else{
                    if (left){
                        left --;
                        res ++;
                    }                      
                    else
                        res +=2;
                    i ++;
                }       
            }        
        }          
        // 栈中剩余的左括号
        res += left * 2;
        return res;
    }
};

结果：