LeetCode--22. Generate Parentheses

题目链接：https://leetcode.com/problems/generate-parentheses/submissions/

要求生成n组合法的括号序列，也就是2n个字符，每个字符取自'('或')'，且这个字符序列是合法的Parenthesis（括号）。

思路一：最朴素的方法就是把所有的排列情况枚举出来，说到排列的枚举当然小意思，可以参考这一篇https://blog.csdn.net/To_be_to_thought/article/details/85168167，当然本题枚举更简单：就是在2n个位置上选择'('或')'，一共有2^(2n)种情况。

接下来就是要弄清楚怎样判断一个合法的括号序列这个问题，先来看LeetCode-20. Valid Parentheses这道题目，借助栈的帮助可以帮助我们判断括号字符串的合法性，因为只有一种括号，这里可以用栈来判断，也可以用计数的方法：'('一定出现在开头，最终'('和')'的数目一样多的，并且在括号字符串的第0位到某一位上累计的'('的数目大于或等于‘)’的数目。计数判断的代码如下：

public static boolean isValid(String s)
    {
        int balance=0;
        for(int i=0;i<s.length();i++)
        {
            if(s.charAt(i)=='(')
                balance++;
            else
                balance--;
            if(balance<0)
                return false;
        }
        return balance==0?true:false;
    }

最终代码如下：

class Solution {
    
    public static LinkedList<String> ret;
    
    public static char[] record;
    
    public List<String> generateParenthesis(int n) {
        ret=new LinkedList<String>();
        record=new char[n*2];
        generateAll(0,n);
        return ret;
    }
    
    public static void generateAll(int idx,int n)
    {
        if(idx==2*n)
        {
            String tmp=new String(record);
            if(isValid(tmp))
                ret.add(tmp);
            return;
        }
        
        record[idx]='(';
        generateAll(idx+1,n);
        record[idx]=')';
        generateAll(idx+1,n);
    }
    
    
    public static boolean isValid(String s)
    {
        int balance=0;
        for(int i=0;i<s.length();i++)
        {
            if(s.charAt(i)=='(')
                balance++;
            else
                balance--;
            if(balance<0)
                return false;
        }
        return balance==0?true:false;
    }
}

思路二：怎样生成字符串之前就避免非法括号序列的生成呢？可以将左括号和右括号数量作为递归的参数传递实现实时检查：

public class Solution{

    public static LinkedList<String> ret;
    public static char[] record;
    public static int left=0;
    public static int right=0;

    public static List<String> generateParenthesis(int n) {

        ret=new LinkedList<>();
        record=new char[2*n];
        backtrace(0,n);
        return ret;
    }

    public static void backtrace(int idx,int n)
    {
        if(idx==2*n)
        {
            ret.add(new String(record));
            return;
        }
        if(left<n)
        {
            record[idx]='(';
            left++;
            backtrace(idx+1,n);
            left--;
        }

        if(right<left && right<n)
        {
            record[idx]=')';
            right++;
            backtrace(idx+1,n);
            right--;
        }
    }
}

官方解答与上面代码相似：

class Solution {

    public static LinkedList<String> ret;
    
    public List<String> generateParenthesis(int n) {
        ret=new LinkedList<String>();
        backtrace("",0,0,n);
        return ret;
    }
    
    public static void backtrace(String s,int left,int right,int n)
    {
        if(s.length()==2*n)
        {
            ret.add(s);
            return;
        }
        if(left<n)
            backtrace(s+'(',left+1,right,n);
        
        if(right<left)
            backtrace(s+')',left,right+1,n);
    }
}