[Swift]LeetCode894. 所有可能的满二叉树 | All Possible Full Binary Trees

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

A full binary tree is a binary tree where each node has exactly 0 or 2 children.

Return a list of all possible full binary trees with N nodes.  Each element of the answer is the root node of one possible tree.

Each node of each tree in the answer must have node.val = 0.

You may return the final list of trees in any order. 

Example 1:

Input: 7
Output: [[0,0,0,null,null,0,0,null,null,0,0],[0,0,0,null,null,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,null,null,null,null,0,0],[0,0,0,0,0,null,null,0,0]]
Explanation:

Note:

• 1 <= N <= 20

---

满二叉树是一类二叉树，其中每个结点恰好有 0 或 2 个子结点。

返回包含 N 个结点的所有可能满二叉树的列表。 答案的每个元素都是一个可能树的根结点。

答案中每个树的每个结点都必须有 node.val=0。

你可以按任何顺序返回树的最终列表。

示例：

输入：7
输出：[[0,0,0,null,null,0,0,null,null,0,0],[0,0,0,null,null,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,null,null,null,null,0,0],[0,0,0,0,0,null,null,0,0]]
解释：

提示：

• 1 <= N <= 20

---

116ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var countToTrees: [Int: [TreeNode]] = [
        1: [TreeNode(0)]
    ]

    func allPossibleFBT(_ N: Int) -> [TreeNode?] {
        if N % 2 == 0 || N < 0 {
            return []
        } else if let trees = countToTrees[N] {
            return trees
        }
        
        var fbts = [TreeNode]()
        
        let remaining = N - 1
        var leftCount = 1
        while leftCount < N - 1 {
            let leftFbts = allPossibleFBT(leftCount)
            let rightFbts = allPossibleFBT(remaining - leftCount)
            
            for lfbt in leftFbts {
                for rfbt in rightFbts {
                    let root = TreeNode(0)
                    root.left = lfbt
                    root.right = rfbt
                    fbts.append(root)
                }
            }
            
            leftCount += 2
        }
        
        countToTrees[N] = fbts
        return fbts
    }
}

---

120ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var dict: Dictionary<Int,[TreeNode]> = [:]
    func allPossibleFBT(_ N: Int) -> [TreeNode?] {
        if N % 2 == 0 {
            return []
        }
        
        return expand(N - 1)
    }
    
    private func expand(_ N: Int) -> [TreeNode] {
        var result: [TreeNode] = []
        if N == 0 {
            return [TreeNode(0)]
        } else if N == 2 {
            let newNode = TreeNode(0)
            newNode.left = TreeNode(0)
            newNode.right = TreeNode(0)
            result.append(newNode)
            return result
        } else {
            if let nodes = dict[N] {
                return nodes
            }
            for i in 0...(N - 2)/2 {
                let left = i * 2
                let right = (N - 2) - left
                let leftNodes = expand(left)
                let rightNodes = expand(right)
                for lNode in expand(left) {
                    for rNode in expand(right) {
                        let newNode = expand(2)[0]
                        newNode.left = lNode
                        newNode.right = rNode
                        result.append(newNode)
                    }
                }
            }
            dict[N] = result
            return result
        }
    }
}

---

136ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func allPossibleFBT(_ N: Int) -> [TreeNode?] {
    if N == 1 {
        return [TreeNode(0)]
    } else if N < 1 || N % 2 == 0 {
        return []
    }
    
    var arr: [TreeNode] = []
    for i in stride(from: 1, to: N-1, by: 2) {
        let lArr = allPossibleFBT(i)
        let rArr = allPossibleFBT(N-i-1)
        
        for j in 0..<lArr.count {
            for k in 0..<rArr.count {
                let t = TreeNode(0)
                t.left = lArr[j]
                t.right = rArr[k]
                arr.append(t)
            }
        }
    }    
    return arr
    }
}

Runtime: 152 ms

Memory Usage: 23.9 MB

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var cache:[Int:[TreeNode?]] = [Int:[TreeNode?]]()
    func allPossibleFBT(_ N: Int) -> [TreeNode?] {
        var N = N
        var res:[TreeNode?] = [TreeNode?]()
        if N % 2==0 {return res}
        if cache[N] != nil {return []}
        if N == 1
        {
            res.append(TreeNode(0))
            return res
        }
        N -= 1
        for i in stride(from:1,to:N,by:2)
        {
            var left:[TreeNode?] = allPossibleFBT(i)
            var right:[TreeNode?] = allPossibleFBT(N - i)
            for nl in left
            {
                for nr in right
                {
                    var cur:TreeNode? = TreeNode(0)
                    cur?.left = nl
                    cur?.right = nr
                    res.append(cur)
                }
            }
        }
        cache[N] = res
        return res
    }
}