[Swift]LeetCode951. 翻转等价二叉树 | Flip Equivalent Binary Trees

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

For a binary tree T, we can define a flip operation as follows: choose any node, and swap the left and right child subtrees.

A binary tree X is flip equivalent to a binary tree Y if and only if we can make X equal to Y after some number of flip operations.

Write a function that determines whether two binary trees are flip equivalent.  The trees are given by root nodes root1 and root2. 

Example 1:

Input: root1 = [1,2,3,4,5,6,null,null,null,7,8], root2 = [1,3,2,null,6,4,5,null,null,null,null,8,7]
Output: true
Explanation: We flipped at nodes with values 1, 3, and 5.

 

Note:

1. Each tree will have at most 100 nodes.
2. Each value in each tree will be a unique integer in the range [0, 99].

---

我们可以为二叉树 T 定义一个翻转操作，如下所示：选择任意节点，然后交换它的左子树和右子树。

只要经过一定次数的翻转操作后，能使 X 等于 Y，我们就称二叉树 X 翻转等价于二叉树 Y。

编写一个判断两个二叉树是否是翻转等价的函数。这些树由根节点 root1和 root2 给出。

示例：

输入：root1 = [1,2,3,4,5,6,null,null,null,7,8], root2 = [1,3,2,null,6,4,5,null,null,null,null,8,7]
输出：true
解释：We flipped at nodes with values 1, 3, and 5.

 

提示：

1. 每棵树最多有 100 个节点。
2. 每棵树中的每个值都是唯一的、在 [0, 99] 范围内的整数。

---

16ms

/**
 * 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 flipEquiv(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
        if root1 == nil {return root2 == nil}
        if root2 == nil {return root1 == nil}
        if root1!.val != root2!.val {return false}
        if flipEquiv(root1!.left, root2!.left) && flipEquiv(root1!.right, root2!.right)
        {
            return true
        }
        if flipEquiv(root1!.left, root2!.right) && flipEquiv(root1!.right, root2!.left)
        {
            return true
        }
        return false
    }
}

---

16ms

/**
 * 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 flipEquiv(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
        if root1 == nil && root2 == nil {
            return true
        }
        guard let root1 = root1, let root2 = root2 else {
            return false
        }
        guard root1.val == root2.val else {
            return false
        }
        return (flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right)) || (flipEquiv(root1.left, root2.right) && flipEquiv(root1.right, root2.left))
    }
}

---

20ms

/**
 * 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 flipEquiv(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
        if root1 == nil && root2 == nil { return true }
        if (root1 != nil && root2 == nil) || (root1 == nil && root2 != nil) {return false}
        
        var root1 = root1
        
        var level1:  [TreeNode?] = [root1]
        var level2:  [TreeNode?] = [root2]
        var level1n:  [TreeNode?] = []
        var level2n:  [TreeNode?] = []
        var rr = 0
        while level1.count > 0 {
            if level1.count != level2.count { return false }
            print(rr)
            rr += 1
            if level1.count == 1 {
                if level1[0] == nil && level2[0] != nil { return false }
                if level1[0] != nil && level2[0] == nil { return false }
                if level1[0] == nil && level2[0] == nil { continue }
                if level1[0]?.val != level2[0]?.val { return false }
            } else {
                var i = 0
                while i < level1.count - 1 {
                    defer { i += 2 }
                    if level1[i] == nil && level2[i] == nil && level1[i+1] == nil && level2[i+1] == nil { continue }
                    if level1[i] != nil && level2[i] != nil && level1[i]?.val == level2[i]?.val && level1[i+1] != nil && level2[i+1] != nil && level1[i+1]?.val == level2[i+1]?.val { continue }
                    
                    if level1[i] != nil && level2[i] != nil && level1[i+1] == nil && level2[i+1] == nil && level1[i]?.val == level2[i]?.val { continue }
                    
                    if level1[i] == nil && level2[i] == nil && level1[i+1] != nil && level2[i+1] != nil && level1[i+1]?.val == level2[i+1]?.val { continue }
                    
                    if level1[i] != nil && level2[i] != nil && level1[i+1] != nil && level2[i+1] != nil && level1[i]?.val == level2[i+1]?.val {
                        var tmp = level1[i]
                        level1[i] = level1[i+1]
                        level1[i+1] = tmp
                        continue
                    }
                    if level1[i] != nil && level2[i] == nil && level1[i+1] == nil && level2[i+1] != nil && level1[i]?.val == level2[i+1]?.val {
                        var tmp = level1[i]
                        level1[i] = level1[i+1]
                        level1[i+1] = tmp
                        continue
                    }
                    
                    if level1[i] == nil && level2[i] != nil && level1[i+1] != nil && level2[i+1] == nil && level1[i+1]?.val == level2[i]?.val {
                        var tmp = level1[i]
                        level1[i] = level1[i+1]
                        level1[i+1] = tmp
                        continue
                    }
                    
                    return false
                }
            }
            
            for node in level1 {
                if let node = node {
                    level1n.append(node.left)
                    level1n.append(node.right)
                }
            }
            
            for node in level2 {
                if let node = node {
                    level2n.append(node.left)
                    level2n.append(node.right)
                }
            }
            
            level1 = level1n
            level2 = level2n
            level1n = []
            level2n = []
        }
        
        return true
    }
}

---

24ms

/**
 * 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 flipEquiv(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
        
        if root1 == nil && root2 == nil {
            return true
        } else if root1 == nil {
            return false
        } else if root2 == nil {
            return false
        }
        
        let _r1 = root1!
        let _r2 = root2!
        
        return _r1.val == _r2.val &&
        (flipEquiv(_r1.left, _r2.right) || flipEquiv(_r1.left, _r2.left)) &&
        (flipEquiv(_r1.right, _r2.left) || flipEquiv(_r1.right, _r2.right))
    }
}

---

40ms

class Solution {
    static let size = 100
    var m1: Array<Array<Int>> = [[Int]].init(repeating: [Int].init(repeating: -1, count: size), count: size)
    var m2: Array<Array<Int>> = [[Int]].init(repeating: [Int].init(repeating: -1, count: size), count: size)
    
    func flipEquiv(_ root1: TreeNode?, _ root2: TreeNode?) -> Bool {
        var s1: Int = 0
        var s2: Int = 0
        treeMap(root1, &m1, 0, size: &s1)
        treeMap(root2, &m2, 0, size: &s2)
        if s1 != s2 { return false }
        return checkEquiv(m1, m2)
    }
    
    func checkEquiv(_ r1: [[Int]], _ r2: [[Int]]) -> Bool  {
        for i in 0..<Solution.size {
            for j in 0..<Solution.size {
                if r1[i][j] != r2[i][j] {
                    return false
                }
            }
        }
        return true
    }
    
    func treeMap(_ node: TreeNode?,
                 _ arr: inout [[Int]],
                 _ lvl: Int,
                 size: inout Int) {
        if let n = node {
            size += 1
            if let r = n.right {
                arr[n.val][r.val] = lvl
                treeMap(r, &arr, lvl+1, size: &size)
            }
            if let l = n.left {
                arr[n.val][l.val] = lvl
                treeMap(l, &arr, lvl+1, size: &size)
            }
        }
    }
}