[Leetcode] 22. Generate Parentheses

Problem:

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:

[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]

Idea:
1. Use a recursive function list all situations.
- For every situation, use a symbol to record the number of ‘(’ on the left side.
- If one ‘(’ is added into the string, the left number of ‘()’ to be added decreases by 1.
- When the function finishes, the symbol should be 0 and the left number should be 0, too.
2. Use Binary Tree. Constructing a Btree for every situation, regard left node as ‘(’ and right ‘)’. After listing all cases, use inorder traversal to all Btrees, which results come from.(But it seems not to be efficient, need some improvement.)

Solution: (for idea No.1)

class Solution(object):
    res = []
    def construct(self,symbol,num,string):
        if num == 0 and symbol == 0:
            self.res.append(string)
        elif symbol == 0:
            self.construct(symbol+1,num-1,string+"(")
        elif symbol > 0:
            self.construct(symbol-1,num,string+")")
            if num != 0:
                self.construct(symbol+1,num-1,string+"(")

    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        self.res = []
        if n == 1:
            return ["()"]
        self.construct(0,n,"")
        return self.res

Another good solutions from here
1. Here I wrote an actual Python generator. I allow myself to put the yield q at the end of the line because it’s not that bad and because in “real life” I use Python 3 where I just say yield from generate(…).

def generateParenthesis(self, n):
    def generate(p, left, right):
        if right >= left >= 0:
            if not right:
                yield p
            for q in generate(p + '(', left-1, right): yield q
            for q in generate(p + ')', left, right-1): yield q
    return list(generate('', n, n))

2.Parameter open tells the number of “already opened” parentheses, and I continue the recursion as long as I still have to open parentheses (n > 0) and I haven’t made a mistake yet (open >= 0).

def generateParenthesis(self, n, open=0):
    if n > 0 <= open:
        return ['(' + p for p in self.generateParenthesis(n-1, open+1)] + \
               [')' + p for p in self.generateParenthesis(n, open-1)]
    return [')' * open] * (not n)

Ref:
about Python yield