[Swift]LeetCode22. 括号生成 | Generate Parentheses

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9890477.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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:

[
  "((()))",
  "(()())",
  "(())()",
  "()(())",
  "()()()"
]

---

给出 n 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。

例如，给出 n = 3，生成结果为：

[
  "((()))",
  "(()())",
  "(())()",
  "()(())",
  "()()()"
]

---

【回溯法】 思路和算法

只有在我们知道序列仍然保持有效时才添加 '(' or ')'，而不是像方法一那样每次添加。我们可以通过跟踪到目前为止放置的左括号和右括号的数目来做到这一点，

如果我们还剩一个位置，我们可以开始放一个左括号。 如果它不超过左括号的数量，我们可以放一个右括号。

class Solution {
    func generateParenthesis(_ n: Int) -> [String] {
        var ans:[String] = [String]()
        backtrack(&ans, "", 0, 0, n)
        return ans
    }
    
    func backtrack(_ ans: inout [String], _ cur:String, _ open:Int, _ close:Int, _ max:Int)
    {
        if cur.count == max * 2
        {
            ans.append(cur)
            return
        }
        if open < max
        {
            backtrack(&ans, cur+"(", open+1, close, max)
        }
        if close < open
        {
            backtrack(&ans, cur+")", open, close+1, max)
        }
    }
}

---

【闭合数】思路

为了枚举某些内容，我们通常希望将其表示为更容易计算的不相交子集的总和。

考虑有效括号序列 S 的闭包数：至少存在index> = 0，使得 S[0], S[1], ..., S[2*index+1]是有效的。 显然，每个括号序列都有一个唯一的闭包号。 我们可以尝试单独列举它们。

算法

对于每个闭合数 c，我们知道起始和结束括号必定位于索引 0 和 2*c + 1。然后两者间的 2*c 个元素一定是有效序列，其余元素一定是有效序列。

class Solution {
    func generateParenthesis(_ n: Int) -> [String] {
        var ans:[String] = [String]()
        if n == 0
        {
            ans.append("")
        }
        else
        {
            for c in 0..<n
            {
                for left in generateParenthesis(c)
                {
                    for right in generateParenthesis(n-1-c)
                    {
                        ans.append("(" + left + ")" + right)
                    }
                }
            }
        }
        return ans
    }
}

---

 8ms

class Solution {
    func generateParenthesis(_ n: Int) -> [String] {
        var output: [String] = []
        
        handler(output: &output, n: n, left: 0, right: 0, text: "")
        
        return output
    }
    
    func handler(output: inout [String], n: Int, left: Int, right: Int, text: String) {
        // print("left: (left), right: (right)")
        
        if(left == n && right == n) {
            output.append(text)
            return
        }

        if(left <= n && left > right) {
            handler(output: &output, n: n, left: left, right: right + 1, text: text + ")")
        }
        
        if(left < n) {
            handler(output: &output, n: n, left: left + 1, right: right, text: text + "(")
        }
        
    }
}

---

12ms

class Solution {
    func generateParenthesis(_ n: Int) -> [String] {
        var ss = [String]()
        generate(ss: &ss, s: "", open: 0, close: 0, n: n)
        return ss
    }

    private func generate(ss: inout [String], s: String, open: Int, close: Int, n: Int) {
        if s.count == n * 2 && !s.isEmpty {
            ss.append(s)
        }
        if open < n {
            generate(ss: &ss, s: "(s)(", open: open+1, close: close, n: n)
        }
        if close < open {
            generate(ss: &ss, s: "(s))", open: open, close: close+1, n: n)
        }
    }
}

---

12ms

class Solution {
    func generateParenthesis(_ n: Int) -> [String] {
        guard n > 0 else {
            return []
        }
        var result = [String]()
        
        dfs(left: 0, right: 0, buffer: "", result: &result, n: n)
        
        return result
    }

    func dfs(left: Int, right: Int, buffer: String, result: inout [String], n: Int) {
        if left == n && right == n {
            result.append(buffer)
            return
        }
        
        if left < n {
            dfs(left: left + 1, right: right, buffer: buffer + "(", result: &result, n: n)
        }
        
        if left > right {
            dfs(left: left, right: right + 1, buffer: buffer + ")", result: &result, n: n)
        }
    }
}

---

20ms

class Solution {
    func generateParenthesis(_ n: Int) -> [String] {//闭合数
        return generateBracket(n)
    }

    func generateBracket(_ n: Int) -> [String] {
        if n <= 0 {
            return [""]
        }
        

        var bracket : [String] = []
        
        for idx in 0..<n {
            for left in generateBracket(idx) {
                for right in generateBracket(n-idx-1) {
                    bracket.append("((left))(right)")
                }
            }
        }
        
        return bracket
    }
}

---

24ms

class Solution {
    func generateParenthesis(_ n: Int) -> [String] {
        if n == 0 {return []}
        return dfs("",  n, n)
    }

    //遍历叶子节点
    func dfs(_ head:String, _ left:Int, _ right:Int) -> [String] {
        if left == 0 && right == 0 { 
            return [head] 
        }
        var res = [String]()
        if left > 0 {   
            res = res + dfs(head + "(", left-1, right) 
        }
        if right > left  { 
            res = res + dfs(head + ")", left, right-1) 
        }
        return res
    }
}

---

44ms

class Solution {
enum Paren: String {
  case o = "("
  case c = ")"
}

class TreeNode {
  let val: Paren
  var left: TreeNode?
  var right: TreeNode?
  
  init(val: Paren) {
    self.val = val
  }
  
  func treeValues() -> [String] {
    // DFS walk the tree multiple times to print out the tree
    guard (self.left != nil) || (self.right != nil) else {
      return [self.val.rawValue]
    }
    
    var res = [String]()
    for node in [self.left, self.right] {
      if let node = node {
        for s in node.treeValues() {
          res.append(self.val.rawValue + s)
        }
      }
    }
    return res
  }
}

func populateTree(root: TreeNode, maxOpenParens: Int, availOpenParens: Int, availClosedParens: Int) {
  // Implement a BST
  if availOpenParens > 0 { 
    root.left = TreeNode(val: Paren.o)
    populateTree(root: root.left!, maxOpenParens: maxOpenParens, availOpenParens: availOpenParens - 1, availClosedParens: availClosedParens + 1)
  }
  if availClosedParens > 0 { 
    root.right = TreeNode(val: Paren.c)
    populateTree(root: root.right!, maxOpenParens: maxOpenParens, availOpenParens: availOpenParens, availClosedParens: availClosedParens - 1)
  }
}

func generateParenthesis(_ n: Int) -> [String] {
    let root = TreeNode(val: Paren.o)
    populateTree(root: root, maxOpenParens: n, availOpenParens: n - 1, availClosedParens: 1)
    return root.treeValues()
  }
}