我的代码实现（Python）：

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        if n == 0:
            return []
        l = []
        res = []
        self.a(res, l, n)
        return res

    def a(self, res, l, n):
        if len(l) == 2 * n:
            l = ''.join(l)
            res.append(l)
            return
        if self.leftValid(l, n):
            l.append('(')
            self.a(res, l, n)
            l.pop()

        if self.rightValid(l):
            l.append(')')
            self.a(res, l, n)
            l.pop()

    def leftValid(self, l, n):
        left_count = l.count('(')
        if left_count == n:
            return False
        return True

    def rightValid(self, l):
        left_count = l.count('(')
        right_count = l.count(')')
        if left_count > right_count:
            return True
        return False

其实这个题很简单，用个递归就可以完成，不过早上写完代码之后一直有问题，折腾了一天，直到刚才才搞定。原来是在a函数里我本来写了个l_copy=l，然后l给self.leftValid，l_copy给self.rightValid，然后一直搞不明白咋回事，想法没问题啊，代码实现也没问题啊，怎么最后就只输出一个解呢！发现问题的时候恍然大悟，l_copy是对l的浅拷贝，对l的操作也会引起l_copy的改变，这是问题所在！对Python使用还是不熟啊！

最后看了下琨哥的代码，比我的简洁多了！

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        if n==0:
            return []
        res = []
        self.helpler(n,n,'',res)
        return res
    
    def helpler(self,l,r,item,res):
        if l>r:
            return
        if l==0 and r==0:
            res.append(item)
        if l>0:
            self.helpler(l-1, r, item+'(', res)
        if r>0:
            self.helpler(l, r-1, item+')', res)

都是递归，区别在于他的递归会生成所有的组合可能，然后判断，如果非法即返回；而我的是先判断，如果在加一个合法，那就加，如果非法那就不加。打个比喻，他是先进门，看看屋里危险与否，如果危险那就出来；我的是现在门口张望，如果屋里危险那就不进了，安全才进。

按道理讲，我的算法效率应该更高，因为我不会生成所有组合可能。但是执行时间我的是70ms左右，而他的是50ms左右，我想我的代码实现耗时就耗时在函数rightValid ()这，因为它会计算(和)的个数，且对结果的保存最开始list，最后又有个转换。