Leetcode 22. Generate Parentheses 回溯法

题目描述

给定一个数字 n，生成有 n 对的括号，都是符合规定的括号组合。

例如，给定 n = 3，需要返回

[
  "((()))",
  "(()())",
  "(())()",
  "()(())",
  "()()()"
]

解题思路

这题是很经典的一道题目，有很多解法，最方便的解法是回溯法。但是可能略微有点难理解。代码之后有一个回溯递归调用的例子，看了以后就清楚多了。

回溯的思想是，如果当前括号数已经足够，那么就把当前的结果加到返回结果里。如果当前的开括号不够，那么添加一个开括号，继续去回溯。如果当前的闭括号数目比开括号少，那么添加一个闭括号，继续去回溯。

代码中有两点限制了返回的结果一定是有效的：

1. 因为开括号最多添加 n 个，闭括号也是，所以当总长度为 2*n 时，两个括号的数目一定是相同的
2. 只有当闭括号的数目比开括号的数目少的时候，才添加闭括号，这时候，它的前面一定有一个开括号可以与之对应

综上所述，一定会返回符合条件的括号。

代码

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> v;
        backtrack(v, "", 0, 0, n);
        return v;
    }

    void backtrack(vector<string>& v, string current, int open, int close, int num){
        if (current.size() == num * 2){
            v.push_back(current);
            return;
        }
        if (open < num){
            backtrack(v, current + "(", open + 1, close, num);
        }
        if (close < open){
            backtrack(v, current + ")", open, close + 1, num);
        }
    }
};

当 n = 2 时的递归调用情况：

backtrack(v, "", 0, 0, 2){
    backtrack(v, "(", 1, 0, 2){
        backtrack(v, "((", 2, 0, 2){
            backtrack(v, "(()", 2, 1, 2){
                backtrack(v, "(())", 2, 2, 2){
                    push;return;
                }
                return;
            }
            return;
        }
        // open = 1, close = 0
        backtrack(v, "()", 1, 1, 2){
            backtrack(v, "()", 1, 1, 2){
                backtrack(v, "()(", 2, 1, 2){
                    backtrack(v, "()()", 2, 2, 2){
                        push;return;
                    }
                    return;
                }
                return;
            }
            return;
        }
        return;
    }
    return;
}