括号匹配问题

20.括号有效性-栈

20. 有效的括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = “()”

输出：true

示例 2：

输入：s = “()[]{}”

输出：true

示例 3：

输入：s = “(]”

输出：false

解题思路
括号的有效性判断在笔试中和现实中都很常见，比如说我们写的代码，编辑器会检查括号是否正确闭合。而且我们的代码可能会包含三种括号 {}，判断起来有一点难度。

解决这个问题之前，我们先降低难度，思考一下，如果只有一种括号 ()，应该如何判断字符串组成的括号是否有效呢？

假设字符串中只有圆括号，如果想让括号字符串有效，那么必须做到：

每个右括号 ) 的左边必须有一个左括号 ( 和它匹配。

比如说字符串 ()))(( 中，中间的两个右括号左边就没有左括号匹配，所以这个括号组合是无效的。

bool isValid(string str) {
    // 待匹配的左括号数量
    int left = 0;
    for (int i = 0; i < str.size(); i++) {
        if (s[i] == '(') {
            left++;
        } else {
            // 遇到右括号
            left--;
        }

        // 右括号太多
        if (left == -1)
            return false;
    }
    // 是否所有的左括号都被匹配了
    return left == 0;
}

果只有圆括号，这样就能正确判断合法性。对于三种括号的情况，我一开始想模仿这个思路，定义三个变量left1，left2，left3分别处理每种括号，虽然要多写不少 if else 分支，但是似乎可以解决问题。但实际上直接照搬这种思路是不行的，比如说只有一个括号的情况下(())是合法的，但是多种括号的情况下，[(])显然是不合法的。仅仅记录每种左括号出现的次数已经不能做出正确判断了，我们要加大存储的信息量，可以利用栈来模仿类似的思路。栈是一种先进后出的数据结构，处理括号问题的时候尤其有用。我们这道题就用一个名为left的栈代替之前思路中的left变量，遇到左括号就入栈，遇到右括号就去栈中寻找最近的左括号，看是否匹配：

class Solution {
private:
    unordered_map<char, char> matchMap_ = {
        {')', '('},
        {']', '['},
        {'}', '{'}
    };
public:
    bool isValid(string s) {
        stack<char> left;
        for (char c : s) {
            if (c == '(' || c == '[' || c == '{') {
                left.push(c);
            } else {
                if (left.empty()) {
                    return false;
                }
                char l = left.top();
                left.pop();
                if (matchMap_[c] != l) {
                    return false;
                }
            }
        }
        return left.empty();
    }
};

平衡括号串-贪心算法

921. 使括号有效的最少添加

只有满足下面几点之一，括号字符串才是有效的：

它是一个空字符串，或者
它可以被写成 AB （A 与 B 连接）, 其中 A 和 B 都是有效字符串，或者
它可以被写作 (A)，其中 A 是有效字符串。
给定一个括号字符串 s ，在每一次操作中，你都可以在字符串的任何位置插入一个括号

例如，如果 s = “()))” ，你可以插入一个开始括号为 “(()))” 或结束括号为 “())))” 。
返回 为使结果字符串 s 有效而必须添加的最少括号数。

示例 1：

输入：s = “())”
输出：1
示例 2：

输入：s = “(((”
输出：3

解题分析
判断括号有效性的方法一般都是从左到右遍历，根据左括号和右括号的数量对比来判断是否是有效的括号串。

本题是类似的，具体可以看代码和注释。核心思路是以左括号为基准，通过维护对右括号的需求数 need，来计算最小的插入次数。

需要注意两个地方：

1、当 need == -1 的时候意味着什么？

因为只有遇到右括号 ) 的时候才会 need–，need == -1 意味着右括号太多了，所以需要插入左括号。

比如说 s = “))” 这种情况，需要插入 2 个左括号，使得 s 变成 “()()”，才是一个有效括号串。

2、算法为什么返回 res + need？

因为 res 记录的左括号的插入次数，need 记录了右括号的需求，当 for 循环结束后，若 need 不为 0，那么就意味着右括号还不够，需要插入。

比如说 s = “))(” 这种情况，插入 2 个左括号之后，还要再插入 1 个右括号，使得 s 变成 “()()()”，才是一个有效括号串。

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译。
// 本代码的正确性已通过力扣验证，如有疑问，可以对照 java 代码查看。

class Solution {
public:
    int minAddToMakeValid(string s) {
        // res 记录插入次数
        int res = 0;
        // need 变量记录右括号的需求量
        int need = 0;

        for (int i = 0; i < s.length(); i++) {
            if (s[i] == '(') {
                // 对右括号的需求 + 1
                need++;
            }

            if (s[i] == ')') {
                // 对右括号的需求 - 1
                need--;

                if (need == -1) {
                    need = 0;
                    // 需插入一个左括号
                    res++;
                }
            }
        }

        return res + need;
    }
};

class Solution {
public:
    int minAddToMakeValid(string s) {
        int ans = 0;
        int leftCount = 0;
        for (auto &c : s) {
            if (c == '(') {
                leftCount++;
            } else {
                if (leftCount > 0) {
                    leftCount--;
                } else {
                    ans++;
                }
            }
        }
        ans += leftCount;
        return ans;
    }
};

作者：力扣官方题解
链接：https://leetcode.cn/problems/minimum-add-to-make-parentheses-valid/solutions/1855025/shi-gua-hao-you-xiao-de-zui-shao-tian-ji-gcxu/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

1541 题「平衡括号字符串的最少插入次数」

https://leetcode.cn/problems/minimum-insertions-to-balance-a-parentheses-string/
给你一个括号字符串 s ，它只包含字符 ‘(’ 和 ‘)’ 。一个括号字符串被称为平衡的当它满足：

任何左括号 ‘(’ 必须对应两个连续的右括号 ‘))’ 。
左括号 ‘(’ 必须在对应的连续两个右括号 ‘))’ 之前。
比方说 “())”， “())(())))” 和 “(())())))” 都是平衡的， “)()”， “()))” 和 “(()))” 都是不平衡的。

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

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

示例 1：

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

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译。
// 本代码的正确性已通过力扣验证，如有疑问，可以对照 java 代码查看。

class Solution {
public:
    int minInsertions(string s) {
        // need 记录需右括号的需求量
        int res = 0, need = 0;

        for (int i = 0; i < s.length(); i++) {
            // 一个左括号对应两个右括号
            if (s[i] == '(') {
                need += 2;
                if (need % 2 == 1) {
                    // 插入一个右括号
                    res++;
                    need--;
                }
            }

            if (s[i] == ')') {
                need--;
                // 说明右括号太多了
                if (need == -1) {
                    // 需要插入一个左括号
                    res++;
                    // 同时，对右括号的需求变为 1
                    need = 1;
                }
            }
        }

        return res + need;
    }
};

32.最长有效括号-栈+动态规划

32. 最长有效括号
给你一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长有效（格式正确且连续）括号子串的长度。

示例 1：

输入：s = “(()”
输出：2
解释：最长有效括号子串是 “()”
示例 2：

输入：s = “)()())”
输出：4
解释：最长有效括号子串是 “()()”
示例 3：

输入：s = “”
输出：0

解题思路
栈+ 动态规划

Stack<Integer> stk = new Stack<>();
for (int i = 0; i < s.length(); i++) {
    if (s.charAt(i) == '(') {
        // 遇到左括号，记录索引
        stk.push(i);
    } else {
        // 遇到右括号
        if (!stk.isEmpty()) {
            // 配对的左括号对应索引，[leftIndex, i] 是一个合法括号子串
            int leftIndex = stk.pop();
            // 这个合法括号子串的长度
            int len = 1 + i - leftIndex;
        } else {
            // 没有配对的左括号
        }
    }
}

#include <stack>
#include <vector>
#include <string>
#include <algorithm>
class Solution {
public:
    int longestValidParentheses(string s) {
        if (s.empty()) {
            return 0;
        }
        // dp[i] 的定义：记录以 s[i - 1] 结尾的最长合法括号子串长度
        // 比s长度多一位，方便计算1 + i - leftIndex + dp[leftIndex - 1]; 不然要单独判断第一个为左括号的情况;
        // 当第一个元素不确定时，需要用到哨兵思想，即在数组最前面加一个哨兵元素，这样就可以避免边界条件的判断。                                                                                                         
                                                                                                    
        vector<int> dp(s.length() + 1, 0);

        stack<int> stk; // 栈存储左括号的索引
        for (int i = 0; i < s.length(); i++) {
            if (s[i] == '(') {
                // 遇到左括号，记录索引
                stk.push(i);
                dp[i + 1] = 0; // 左括号不可能是合法括号子串的结尾
            } else { // 遇到右括号
                if (!stk.empty()) {
                    // 配对的左括号对应索引
                    int leftIndex = stk.top();
                    stk.pop();
                    // 以这个右括号结尾的最长子串长度；dp[leftIndex - 1 + 1]：左括号前一位的最长子串长度, 当一个为左括号时，存在越界风险
                    int len = 1 + i - leftIndex + dp[leftIndex - 1 + 1];
                    dp[i + 1] = len;
                } else {
                    dp[i + 1] = 0;
                }
            }
        }
        return *max_element(dp.begin(), dp.end());
    }
};

22. 括号生成 - 回溯

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

括号问题可以简单分成两类，一类是前文写过的
括号的合法性判断 ，一类是合法括号的生成。对于括号合法性的判断，主要是借助「栈」这种数据结构，而对于括号的生成，一般都要利用
回溯算法 进行暴力穷举。

// 注意：cpp 代码由 chatGPT🤖 根据我的 java 代码翻译。
// 本代码的正确性已通过力扣验证，如有疑问，可以对照 java 代码查看。

#include <vector>
#include <string>

using namespace std;

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        if (n == 0) return {};
        // 记录所有合法的括号组合
        vector<string> res;
        // 回溯过程中的路径
        string track;
        // 可用的左括号和右括号数量初始化为 n
        backtrack(n, n, track, res);
        return res;
    }

private:
    // 可用的左括号数量为 left 个，可用的右括号数量为 right 个
    void backtrack(int left, int right, string& track, vector<string>& res) {
        // 若左括号剩下的多，说明不合法
        if (right < left) return;
        // 数量小于 0 肯定是不合法的
        if (left < 0 || right < 0) return;
        // 当所有括号都恰好用完时，得到一个合法的括号组合
        if (left == 0 && right == 0) {
            res.push_back(track);
            return;
        }

        // 尝试放一个左括号
        // 选择
        track.push_back('(');
        backtrack(left - 1, right, track, res);
        // 撤消选择
        track.pop_back();

        // 尝试放一个右括号
        // 选择
        track.push_back(')');
        backtrack(left, right - 1, track, res);
        // 撤消选择
        track.pop_back();
    }
};

参考

https://mp.weixin.qq.com/s/plxWQsTgW6LW3T7yBAXjQg