LeetCode String 22 Generate Parentheses

22. Generate Parentheses

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]

solution 1: DP

从 n-1 到 n 相当于在每个 n-1 结果的字符串插入一个 ”()“ 。基本情况为 n = 1，此时返回值为 ["()"]。

假设 n = 3,
n-1 = 2 的结果是：
$["()()","(())"]$
取出第一个结果字符串 “()()”

$"()()"$共有5个插入的位置
$"1(2)3(4)5"$，但是在这五个位置分别插入 “()” 会出现duplicates，所以需要先用HashSet来保存，确保唯一性，然后把结果传递给ArrayList

    public List<String> generateParenthesis(int n) {
        List<String> list = new ArrayList<>();
        list.add("()");
        if (n == 1) return list;
        List<String> resList = new ArrayList<>();
        List<String> prev = generateParenthesis(n-1);
        HashSet<String> res = new HashSet<>();
        for (String str : prev) {
            int ptr = 0;
            while (ptr < str.length()) {
                String str1 = str.substring(0,ptr);
                String str2 = str.substring(ptr);
                String pref = "()";
                StringBuffer tmp = new StringBuffer();
                tmp.append(str1).append(pref).append(str2);
                res.add(tmp.toString());
                ptr++;
            }
        }
        for (String s : res) {
            resList.add(s);
        }
        return resList;
    }

solution 2: DP

对上面的算法进行一些优化，插入 “()” 时会产生多余的duplicas，如何减少duplicates呢？由于每一个 n 产生的结果都是相互对称的或者内部对称，如n = 3 时，结果为 $["()()()","(()())","((()))","()(())","(())()"]$，前面三个结果时内部对称的，后面两个相互对称。
由于这个特性，我们在插入 ”()“ 时，实际只需要插入到中间即可，如对于$"()(())"$，有4个插入位置，$"1(2)3(4())"$，同时由于字符串长度恰好是 n 的2倍，于是ptr的最大值就是 n。

    public List<String> generateParenthesis(int n) {
        List<String> list = new ArrayList<>();
        list.add("()");
        if (n == 1) return list;
        List<String> resList = new ArrayList<>();
        List<String> prev = generateParenthesis(n-1);
        HashSet<String> res = new HashSet<>();
        for (String str : prev) {
            int ptr = 0;
            while (ptr < n) {
                String str1 = str.substring(0,ptr);
                String str2 = str.substring(ptr);
                String pref = "()";
                StringBuffer tmp = new StringBuffer();
                tmp.append(str1).append(pref).append(str2);
                res.add(tmp.toString());
                ptr++;
            }
        }
        for (String s : res) {
            resList.add(s);
        }
        return resList;
    }

solution 3: Brute Force

复杂度太高，不可取

solution 4: Backtracking

Instead of adding ${}^{\prime }{(}^{\prime }$ or ${}^{\prime }{)}^{\prime }$ every time, let’s only add them when we know it will remain a valid sequence. We can do this by keeping track of the number of opening and closing brackets we have placed so far.

We can start an opening bracket if we still have one (of n) left to place. And we can start a closing bracket if it would not exceed the number of opening brackets.

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> ans = new ArrayList();
        backtrack(ans, "", 0, 0, n);
        return ans;
    }

    public void backtrack(List<String> ans, String cur, int open, int close, int max){
        if (cur.length() == max * 2) {
            ans.add(cur);
            return;
        }

        if (open < max)
            backtrack(ans, cur+"(", open+1, close, max);
        if (close < open)
            backtrack(ans, cur+")", open, close+1, max);
    }
}

这个是最快的解法。主要就是确保"(“和”)"的数目一致