How to Generate Parentheses using Bruteforce or Depth First Sear

  • 时间：2020-09-23 15:11:59
  • 分类：网络文摘
  • 阅读：113 次

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:

1
2
3
4
5
6
7

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

We can use the following two algorithms: bruteforce, or backtracking/Depth First Search Algorithm to generate n pairs of valid Parentheses. We can use recursion to implement both algorithms as the follows.

Bruteforce Algorithm to Generate Parentheses

First, we can check if a given string is a valid Parentheses. If we meet a ‘(‘ we increment the balance and ‘)’ we decrement it. At any time, if the balance is negative, it is invalid. Finally a valid Parentheses should have zero balance at the end.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

bool isValidParentheses(const string &s) {
    int balance = 0;
    for (int i = 0; i < s.size(); ++ i) {
        if (s[i] == '(') {
            balance ++;
        } else {
            balance --;
            if (balance < 0) {
                return false;
            }
        }
    }
    return balance == 0;
}
bool isValidParentheses(const string &s) {
    int balance = 0;
    for (int i = 0; i < s.size(); ++ i) {
        if (s[i] == '(') {
            balance ++;
        } else {
            balance --;
            if (balance < 0) {
                return false;
            }
        }
    }
    return balance == 0;
}

Then, we can use the recursion to bruteforce all the possible strings and check one-by-one if it is a valid using isValidParentheses method. As each character has two possibilities, and there are N*2 characters, there will be O(2^(2N)) time complexity, and over-all algorithm complexity will be O(n*2^(2N)) including the isValidParentheses which takes O(N).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> r;        
        string cur(n * 2, ' ');
        dfs(r, cur, 0);
        return r;
    }
    
private:
    void dfs(vector<string> &res, string &cur, int pos) {
        if (pos == cur.size()) {
            if (isValidParentheses(cur)) {
                res.push_back(cur);
            }
        } else {
            cur[pos] = '(';
            dfs(res, cur, pos + 1);
            cur[pos] = ')';
            dfs(res, cur, pos + 1);
        }
        
    }
};
class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> r;        
        string cur(n * 2, ' ');
        dfs(r, cur, 0);
        return r;
    }
    
private:
    void dfs(vector<string> &res, string &cur, int pos) {
        if (pos == cur.size()) {
            if (isValidParentheses(cur)) {
                res.push_back(cur);
            }
        } else {
            cur[pos] = '(';
            dfs(res, cur, pos + 1);
            cur[pos] = ')';
            dfs(res, cur, pos + 1);
        }
        
    }
};

Backtracking/DFS Algorithm to Generate Parentheses

Apparently, the performance of the bruteforce algorithm is not ideal as we don’t need to generate the invalid Parentheses in the first place. We can use two counters to remember the number of opening and closed Parentheses respectively, and only backtracking those valid branches. The invalid branches are cut-off and abandoned. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> r;        
        dfs(r, 0, 0, n, "");
        return r;
    }
    
private:
    void dfs(vector<string> &res, int open, int close, int n, string cur) {
        if (cur.size() == 2 * n) {
            res.push_back(cur);
            return;
        }
        if (open < n) {
            dfs(res, open + 1, close, n, cur + "(");
        }
        if (close < open) { // the close Parentheses should be less than the opening Parentheses
            dfs(res, open, close + 1, n, cur + ")");
        }
    }
};
class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> r;        
        dfs(r, 0, 0, n, "");
        return r;
    }
    
private:
    void dfs(vector<string> &res, int open, int close, int n, string cur) {
        if (cur.size() == 2 * n) {
            res.push_back(cur);
            return;
        }
        if (open < n) {
            dfs(res, open + 1, close, n, cur + "(");
        }
        if (close < open) { // the close Parentheses should be less than the opening Parentheses
            dfs(res, open, close + 1, n, cur + ")");
        }
    }
};

The total number of different Parentheses is the n-th Catalan number, which is 1/(n+1)C(2n, n) and the complexity is bounded asymptotically to 4^n/(n*sqrt(n)).

The same algorithm implemented in Python, as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        arr = []
        def dfs(open, close, n, cur):            
            nonlocal arr
            if len(cur) == 2 * n:
                arr.append(cur)
                return            
            if open < n:
                dfs(open + 1, close, n, cur + '(')
            if close < open:
                dfs(open, close + 1, n, cur + ')')            
        dfs(0, 0, n, '')
        return arr
class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        arr = []
        def dfs(open, close, n, cur):            
            nonlocal arr
            if len(cur) == 2 * n:
                arr.append(cur)
                return            
            if open < n:
                dfs(open + 1, close, n, cur + '(')
            if close < open:
                dfs(open, close + 1, n, cur + ')')            
        dfs(0, 0, n, '')
        return arr

–EOF (The Ultimate Computing & Technology Blog) —

推荐阅读：
两车相遇时间是什么时候　 求AB两站的路程　 小玲和小聪收集各种卡片　 三种水果共有多少千克　 汽车比原计划早到1.5小时到达目的地　 果园里有桔子树和梨树共360棵　 原来定价时所期望的利润是多少元？　 男生人数的40％比女生人数的一半还多3人　 某工厂一、二车间共360人　 将侧面积是94.2平方厘米的圆柱拼成一个近似的长方体　
评论列表
添加评论