[leetcode]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:

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

这道题是回溯法的典型问题。我们定义左括号值为1，右括号的值为-1，定义一个数组，长度为2*n,这样可以定义剪枝逻辑如下：

1 如果当前所有的值的和小于零，说明有“)”没有对应的“(”而单独存在，剪掉这个分支

2 如果当前所有的值的和等于零，不剪

3 如果当前所有的值的和大于零，只有当已经遍历到最后一个元素的时候大于零，这是不合法，剪掉。剩下的情况都是合法的，不剪。

明白了剪枝函数，剩下的就简单了。

java代码

public class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> list = new ArrayList<String>();
        int[] x = new int[2*n];
        backTracking(list,x,2*n,0);
        return list;
    }
    public void backTracking(List<String> list,int[] x, int n, int k){
        if(k >= n){
            String s = "";
            for(int i=0;i<x.length;i++){
                if(x[i]==1){
                    s+="(";
                }
                else{
                    s+=")";
                }
            }
            list.add(s);
            return;
        }else{
            x[k] = 1;
            if(can(x,k,n)){
                backTracking(list,x,n,k+1);
            }
            x[k] = -1;
            if(can(x,k,n)){
                backTracking(list,x,n,k+1);
            }
        }
    }
    public boolean can(int[] x, int k,int n){
        int sum = 0;
        for(int i=0;i<=k;i++){
            sum += x[i];
        }
        if(sum < 0){
            return false;
        }
        else{
            if(k==(n-1)){
                if(sum==0){
                    return true;
                }
                else{
                    return false;
                }
            }
            else{
                return true;
            }
            
        }
    }
}

go代码

func generateParenthesis(n int) []string {
	var x []int = make([]int, 2*n)
	var result *[]string = &[]string{}
	generate(result, x, 2*n, 0)
	return *result
}
func generate(result *[]string, x []int, n int, k int) {
	if k == n {
		var tmpResult string = ""
		for _, value := range x {
			if value == 1 {
				tmpResult = tmpResult + "("
			} else {
				tmpResult = tmpResult + ")"
			}
		}
		*result = append(*result, tmpResult)
	} else {
		x[k] = 1
		if can(x, n, k) {
			generate(result, x, n, k+1)
		}
		x[k] = -1
		if can(x, n, k) {
			generate(result, x, n, k+1)
		}

	}
}
func can(x []int, n int, k int) bool {
	var sum int = 0
	var result bool
	for i := 0; i <= k; i++ {
		sum += x[i]
	}
	if sum < 0 {
		result = false
	} else if sum == 0 {
		result = true
	} else {
		if k == n-1 {
			result = false
		} else {
			result = true
		}
	}
	return result
}