【LeetCode 22】括号生成

深搜+剪枝的两种解法：

1. 记录左括号与右括号的剩余数量，每次选择向路径中加入左括号或右括号，当某一种括号剩余量为0，对可能的结果使用栈检查合法性。

效率比较低下，因为检查的过程耗费时间。

    public List<String> generateParenthesis(int n) {
        List<String> answer=new ArrayList<>();
        if(n<=0) return answer;

        generateParenthesisCore(n,n,new StringBuffer(),answer);
        return answer;
    }

    public void generateParenthesisCore(int n, int m, StringBuffer path,
                                        List<String> answer){
        //左括号没有了，检查是否合法
        if(n<=0){
            for(int i=0;i<m;i++){
                path.append(')');
            }
            if(checkPath(path)){
                answer.add(path.toString());
            }
            for(int i=0;i<m;i++){
                path.deleteCharAt(path.length()-1-i);
            }
            return;
        }
        //右括号没有了，直接返回
        if(m<=0){
            return;
        }

        //左右括号都还有，分别追加左括号与有括号，下一层次递归
        generateParenthesisCore(n-1,m,path.append('('),answer);
        path.deleteCharAt(path.length()-1);
        generateParenthesisCore(n,m-1,path.append(')'),answer);
        path.deleteCharAt(path.length()-1);
    }

    public boolean checkPath(StringBuffer path){
        if(path.length()==0){
            return false;
        }
        LinkedList<Character> stack=new LinkedList<>();

        for(int i=0;i<path.length();i++){
            if(path.charAt(i)=='('){
                stack.push(path.charAt(i));
            }
            else{
                if(stack.isEmpty()) return false;
                if(stack.pop()!='(') return false;
            }
        }
        if(!stack.isEmpty()) return false;
        return true;
    }

第二种解法：记录左括号与右括号的剩余数量，如果剩余左括号数量大于剩余右括号数量，那么当前解就是非法的，直接剪枝。最终左右括号数量都为n时，不需要检查，直接加入到解集合。

相比上一个解法效率更高，因为这个方法检查的是动态增长的表达式，而不是最终解。

重点在于：什么情况下表达式是合法的？我本来的想法是表达式使用栈检查合法，但是只要表达式增长过程中始终维持着左括号数量大于等于右括号数量，表达式就是合法的。这个可以记为一个tip。

    public List<String> generateParenthesis(int n) {
        List<String> answer = new ArrayList<>();
        if (n <= 0) return answer;

        generateParenthesisCore(n, n, new StringBuffer(), answer);
        return answer;
    }

    public void generateParenthesisCore(int n, int m, StringBuffer path,
                                        List<String> answer) {

        if (n < 0 || m < 0 || n > m) return;
        if (n == 0 && m == 0) {
            answer.add(path.toString());
            return;
        }
        generateParenthesisCore(n - 1, m, path.append('('), answer);
        path.deleteCharAt(path.length()-1);
        generateParenthesisCore(n, m - 1, path.append(')'), answer);
        path.deleteCharAt(path.length()-1);
    }