Leetcode-括号相关问题

20-有效的括号

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

方法：栈

判断括号的有效性可以使用「栈」这一数据结构来解决。

我们遍历给定的字符串 s。当我们遇到一个左括号时，我们会期望在后续的遍历中，有一个相同类型的右括号将其闭合。由于后遇到的左括号要先闭合，因此我们可以将这个左括号放入栈顶。

当我们遇到一个右括号时，我们需要将一个相同类型的左括号闭合。此时，我们可以取出栈顶的左括号并判断它们是否是相同类型的括号。如果不是相同的类型，或者栈中并没有左括号，那么字符串 s 无效，返回False。

在遍历结束后，如果栈中没有左括号，说明我们将字符串 s 中的所有左括号闭合，返回 True，否则返回 False。

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

class Solution {
public:
    bool isValid(string s) {
    if(s.size()%2==1)
        return false;
     stack<char>left;
     for(auto&ch:s)
     {
        if(ch=='('||ch=='['||ch=='{')
            left.push(ch);
        else
        {
            if(!left.empty()&&leftof(ch)==left.top())
            {
                left.pop();
            }
            else 
                return false;
        }
     }
     return left.empty();
    }
    char leftof(char ch)
    {
        if(ch==')')return '(';
        if(ch==']')return '[';
        return '{';
    }
};

1. 时间复杂度：O（N），一遍循环遍历
2. 空间复杂度：O（N），栈最多存放N个元素

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

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

它是一个空字符串，或者
它可以被写成 AB （A 与 B 连接）, 其中 A 和 B 都是有效字符串，或者
它可以被写作 (A)，其中 A 是有效字符串。

给定一个括号字符串 s ，移动N次，你就可以在字符串的任何位置插入一个括号。

例如，如果 s = "()))" ，你可以插入一个开始括号为 "(()))" 或结束括号为 "())))" 。

返回 为使结果字符串 s 有效而必须添加的最少括号数。

方法：递归栈

参照20-有效的括号，可写出如下代码

class Solution {
public:
    int minAddToMakeValid(string s) {
     stack<char>left;
     int ans=0;
     for(auto&ch:s)
     {
        if(ch=='(')
        {
            left.push(ch);
            ans++;
        }            
        else if(!left.empty()&&left.top()=='(')
        {
            left.pop();
            ans--;
        }
        else
            ans++;   
     }
     return ans;
    }
};

1. 时间复杂度：O（N）
2. 空间复杂度：O（N）

方法二：平衡度

遍历整个字符串，计算当前位置的平衡度。平衡度=‘（’的个数-‘）’的个数，如果平衡度为-1，需要添加一个括号使当前位置的括号有效。

class Solution {
public:
    int minAddToMakeValid(string s) {
    int ans=0,bal=0;
    for(auto&ch:s)
    {
       bal+=ch=='('?1:-1;
        if(bal==-1)
        {
            ans++;
            bal++;
        }  
    }
    return ans+bal;
    }  
};

1. 时间复杂度：O（N）
2. 空间复杂度：O（1）

1541-平衡括号字符串的最少插入次数

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

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

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

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

方法：平衡度

一个左括号对应两个右括号为平衡。我们用变量left记录右括号的需求数，根据need的变化来潘丹是否需要插入，res来保存最少插入次数。
现在想一想，当 need 为什么值的时候，我们可以确定需要进行插入？

首先，类似第一题，当 need == -1 时，意味着我们遇到一个多余的右括号，显然需要插入一个左括号。

比如说当 s = “)”，我们肯定需要插入一个左括号让 s = “()”，但是由于一个左括号需要两个右括号，所以对右括号的需求量变为 1:

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

另外，当遇到左括号时，若对右括号的需求量为奇数，需要插入 1 个右括号。因为一个左括号需要两个右括号嘛，右括号的需求必须是偶数，这一点也是本题的难点。

所以遇到左括号时要做如下判断：

if (s[i] == '(') {
    need += 2;
    if (need % 2 == 1) {
        // 插入一个右括号
        res++;
        // 对右括号的需求减一
        need--;
    }
}

最终代码

int minInsertions(string s) {
    int res = 0, need = 0;

    for (int i = 0; i < s.size(); i++) {
        if (s[i] == '(') {
            need += 2;
            if (need % 2 == 1) {
                res++;
                need--;
            }
        }
        
        if (s[i] == ')') {
            need--;
            if (need == -1) {
                res++;
                need = 1;
            }
        }
    }
    return res + need;
}

1. 时间复杂度：O（N）
2. 空间复杂度：O（1）

22-括号生成

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

方法一：暴力法

我们可以生成所有 2^2n个 ‘(’ 和 ‘)’ 字符构成的序列，然后我们检查每一个是否有效即可。
算法
为了生成所有序列，我们可以使用递归。长度为 n 的序列就是在长度为 n-1 的序列前加一个 ‘(’ 或 ‘)’。
为了检查序列是否有效，我们遍历这个序列，并使用一个变量 balance 表示左括号的数量减去右括号的数量。如果在遍历过程中 balance 的值小于零，或者结束时 balance 的值不为零，那么该序列就是无效的，否则它是有效的。

class Solution {
    bool valid(const string& str) {
        int balance = 0;
        for (char c : str) {
            if (c == '(') {
                ++balance;
            } else {
                --balance;
            }
            if (balance < 0) {
                return false;
            }
        }
        return balance == 0;
    }

    void generate_all(string& current, int n, vector<string>& result) {
        if (n == current.size()) {
            if (valid(current)) {
                result.push_back(current);
            }
            return;
        }
        current += '(';
        generate_all(current, n, result);
        current.pop_back();
        current += ')';
        generate_all(current, n, result);
        current.pop_back();
    }
public:
    vector<string> generateParenthesis(int n) {
        vector<string> result;
        string current;
        generate_all(current, n * 2, result);
        return result;
    }
};

1. 时间复杂度：O(2^2n)，对于2^2n个序列中的每一个，我们用于建立和验证该序列的复杂度为 O(n)。
2. 空间复杂度：O(n)，除了答案数组之外，我们所需要的空间取决于递归栈的深度，每一层递归函数需要 O(1) 的空间，最多递归 2n 层，因此空间复杂度为 O(n)。

方法二：回溯法

思路和算法

方法一还有改进的余地：我们可以只在序列仍然保持有效时才添加 ‘(’ or ‘)’，而不是像 方法一 那样每次添加。我们可以通过跟踪到目前为止放置的左括号和右括号的数目来做到这一点，

如果左括号数量不大于 n，我们可以放一个左括号。如果右括号数量小于左括号的数量，我们可以放一个右括号。

class Solution {
    void backtrack(vector<string>& ans, string& cur, int open, int close, int n) {
        if (cur.size() == n * 2) {
            ans.push_back(cur);
            return;
        }
        if (open < n) {
            cur.push_back('(');
            backtrack(ans, cur, open + 1, close, n);
            cur.pop_back();
        }
        if (close < open) {
            cur.push_back(')');
            backtrack(ans, cur, open, close + 1, n);
            cur.pop_back();
        }
    }
public:
    vector<string> generateParenthesis(int n) {
        vector<string> result;
        string current;
        backtrack(result, current, 0, 0, n);
        return result;
    }
};

1. 时间复杂度：O（4n/√n），在回溯过程中，每个答案需要 O(n) 的时间复制到答案数组中（卡特兰数）。
2. 空间复杂度：O(n)，除了答案数组之外，我们所需要的空间取决于递归栈的深度，每一层递归函数需要 O(1) 的空间，最多递归 2n 层，因此空间复杂度为 O(n)。