【leetcode】Generate Parentheses 算法解析

我的思路

首先初始化一个由n个‘(’组成的string，之后的工作就是把n个')'加入到这个string中。

第一个大循环共循环n次，每次加入一个')'，这个大循环很好理解。 每一次循环的结果都存到一个vector<string>里。

因此我们的 第二层循环就是遍历这个 vector<string>，逐个取出string，并加入一个')'，存入另一个vector。

第三层，也就是最内层的循环就是如何加入这个')'。这里采用从string尾部加入的方法，即每次新加入的')'必须出现在之前加入的')'之前。

例如我们设n=3，初始string就是'((('，当我们加入第一个')'时，只能放在最后，即从0开始第3个位置，得到'((()'，因为如果放在第2位，得到'(()('，那么由于新加入的')'必须出现在之前加入的')'之前，无论此后的')'怎么加入，'(()('的最后一个字符'('将永远没有')'去对应。

好，那么现在我们的vector里有一个string，是"((()"。接下来要加入第2个')'。从哪里加入呢？从左数最少也要从第2位开始加入，因为如果从第1位开始加入，就会出现"()(()"，那么下一次加入的')'将出现在它的左边，那么只能是"())(()"，显然正反括号没有匹配。所以总结一下，所有的加入方式是，从第2位开始，到最后一位结束，但是注意，如果碰到准备加入的位置左边已经有一个')'，就不要继续下去了，因为我们已经规定了”每次新加入的')'必须出现在之前加入的')'之前“，这是为了不出现重复的组合。

C++代码如下：

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        string start(n, '('); // initial: "(((...((", then add ')' to it.
        vector<string> v1(1, start), v2;
        string temp;
        for(int i=0; i<n; i++) { // add one ')' at a time.
            for(auto vec=v1.begin(); vec!=v1.end(); vec++) {
                for(int j=n-i; j<=n+i; j++) { // add from tail. for example, 1st time, (((..( becomes ((((..(), and 2nd time, it becomes (((..(()) and (((..()()
                    temp = *vec;
                    if(temp[j-1]==')') break;
                    temp.insert(temp.begin()+j, ')');
                    v2.push_back(temp);
                }
            }
            swap(v1, v2);
            v2.clear();
        }
        return v1;
    }
};

接下来分析discuss里其他的思路

递归方法

string从'('开始增长，向右逐个增加左括号和右括号。当左括号的个数小于n时，string可以接着增加一个左括号，并把新string丢给递归函数；当右括号的个数小于左括号时，string可以接着增加一个右括号，并把新string丢给递归函数。

递归结束的条件就是 左括号个数==右括号个数==n。

python代码如下：

class Solution:

    def generateParenthesis(self, n):
        if (n == 0):
            return []
        string = "("
        result = []
        left_number = 1
        right_number = 0
        self.solve(left_number, right_number, string, n, result)
        return result

    def solve(self, l_n, r_n, string, n, result):
        if (l_n == r_n and r_n == n):
            result.append(string)
            return

        if (l_n < n):
            self.solve(l_n+1, r_n, string+'(', n, result)

        if (r_n < l_n):
            self.solve(l_n, r_n+1, string+')', n, result)

栈方法（递归方法的栈版本）

这个思路和递归是一样的，只不过 用了栈的方法来保存递归调用的顺序。

首先把'('压入栈，此后每次从栈顶取出string，并压入添加了一个'('或')'的string， 当左括号的个数小于n时，压入增加一个左括号的string；当右括号的个数小于左括号时，压入增加一个右括号的string。当左括号个数+右括号个数==2n时，存入结果list中。

另外还有一个整型栈和这个string栈同步使用，每个string中右括号的个数存在整型栈中，两个栈同步进行pop和push。

Java代码如下:

public List<String> generateParenthesis(int n) {
    ArrayList<String> list = new ArrayList<String>();
    Stack<String> stack = new Stack<String>();
    Stack<Integer> validationStack = new Stack<Integer>();
    stack.push("(");
    validationStack.push(0);
    while(stack.size() != 0)
    {
        String s = stack.pop();
        int v = validationStack.pop();
        if(s.length() == n * 2)
        {
            list.add(s);
            continue;
        }
        if(s.length() - v < n)
        {
            stack.push(s + "(");
            validationStack.push(v);
        }
        if(2 * v < s.length())
        {
            stack.push(s + ")");
            validationStack.push(v+1);
        }
    }
    return list;
}