22. Generate Parentheses*

题目：

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

Example 1:

Input: n = 3
Output: ["((()))","(()())","(())()","()(())","()()()"]

Example 2:

Input: n = 1
Output: ["()"]

Constraints:

• 1 <= n <= 8

解法：

解法一：

其实这个跟上一个电话号码的题类似，我的思路是假设原字符串为()，则新加入的一对括号有三个位置，第一个字符之前（最前面）、第二个字符之前（中间）和第二个字符之后（最后面）。假设原字符串为()()，则新加入的一对括号有五个可能的位置，即第一个字符之前、第二个字符之前......第四个字符之后。

但是由于我用了两个集合，所以空间占用较多，仅少于10.75%的python3提交者

    def generateParenthesis(self, n: int) -> List[str]:
        r=set(['()'])
        s=set()
        i=1
        while(i<n):
            for item in r:
                for j in range(0,len(item)):
                    str_list = list(item)
                    str_list.insert(j, '()')
                    s.add(''.join(str_list))
            r=s.copy()
            s.clear()
            i+=1
        return list(r)

解法二：

看了评论里https://leetcode.com/StefanPochmann的三种解法，emmm...我用的是假的python吧

def generateParenthesis(self, n):
    def generate(p, left, right, parens=[]):
        if left:         generate(p + '(', left-1, right)
        if right > left: generate(p + ')', left, right-1)
        if not right:    parens += p,
        return parens
    return generate('', n, n)

用了递归的方法，需要注意的是parens这个数组。python对可变默认参数的处理，以List为例：List只有在函数定义的时候被初始化，后面每次调用用的都是同一个list。所以可以看到在这个解法中，多次调用generate函数，结果均添加到同一个parens中了。

解法三：

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))

emmm...讲道理我并不是很理解，但是借此机会学习了一下yield的用法。

1.通常的for...in...循环中，in后面是一个数组，这个数组就是一个可迭代对象，类似的还有链表，字符串，文件。它的缺陷是所有数据都在内存中，如果有海量数据的话会非常耗内存。

2.yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator，调用时不会执行该函数，而是返回一个 iterable 对象！在 for 循环执行时，每次循环都会执行函数内部的代码，执行到 yield时，函数就返回一个迭代值，下次迭代时，代码从 yield的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。

解法四：

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)

emmm...有点放弃理解了，最后一行，not n，只有n=0时，才是True，其它任何正数负数，都是False。所以最后一行，只有n=0才会返回open个')'，其它时候返回[]。