[Swift]LeetCode971.翻轉二叉樹以匹配先序遍歷 | Flip Binary Tree To Match Preorder Traversal

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公衆號：山青詠芝（shanqingyongzhi）
➤博客園地址：山青詠芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：http://www.javashuo.com/article/p-otgxutra-me.html 
➤若是連接不是山青詠芝的博客園地址，則多是爬取做者的文章。
➤原文已修改更新！強烈建議點擊原文地址閱讀！支持做者！支持原創！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a binary tree with N nodes, each node has a different value from {1, ..., N}.

A node in this binary tree can be flipped by swapping the left child and the right child of that node.

Consider the sequence of N values reported by a preorder traversal starting from the root.  Call such a sequence of N values the voyage of the tree.

(Recall that a preorder traversal of a node means we report the current node's value, then preorder-traverse the left child, then preorder-traverse the right child.)

Our goal is to flip the least number of nodes in the tree so that the voyage of the tree matches the voyagewe are given.

If we can do so, then return a list of the values of all nodes flipped.  You may return the answer in any order.

If we cannot do so, then return the list [-1]. 

Example 1:

Input: root = [1,2], voyage = [2,1] Output: [-1] 

Example 2:

Input: root = [1,2,3], voyage = [1,3,2] Output: [1] 

Example 3:

Input: root = [1,2,3], voyage = [1,2,3] Output: [] 

Note:

1. 1 <= N <= 100

---

給定一個有 N 個節點的二叉樹，每一個節點都有一個不一樣於其餘節點且處於 {1, ..., N} 中的值。

經過交換節點的左子節點和右子節點，能夠翻轉該二叉樹中的節點。

考慮從根節點開始的先序遍歷報告的 N 值序列。將這一 N 值序列稱爲樹的行程。

（回想一下，節點的先序遍歷意味着咱們報告當前節點的值，而後先序遍歷左子節點，再先序遍歷右子節點。）

咱們的目標是翻轉最少的樹中節點，以便樹的行程與給定的行程 voyage 相匹配。 

若是能夠，則返回翻轉的全部節點的值的列表。你能夠按任何順序返回答案。

若是不能，則返回列表 [-1]。 

示例 1：

輸入：root = [1,2], voyage = [2,1]
輸出：[-1]

示例 2：

輸入：root = [1,2,3], voyage = [1,3,2]
輸出：[1]

示例 3：

輸入：root = [1,2,3], voyage = [1,2,3]
輸出：[] 

提示：

1. 1 <= N <= 100

---

20ms 

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     var p:Int = 0
16     var fed:[Int] = [Int]()
17     func flipMatchVoyage(_ root: TreeNode?, _ voyage: [Int]) -> [Int] {
18         p = 0
19         if dfs(root, voyage)
20         {
21             return fed
22         }
23         else
24         {
25             fed = [Int]()
26             fed.append(-1);
27             return fed;
28         }        
29     }
30     
31     func dfs(_ cur: TreeNode?, _ voyage: [Int]) -> Bool
32     {
33         if cur == nil {return true}
34         if voyage[p] != cur!.val {return false}
35         p += 1
36         if cur!.left == nil
37         {
38             return dfs(cur?.right, voyage)
39         }
40         if cur!.right == nil
41         {
42             return dfs(cur?.left, voyage)
43         }
44         
45         if voyage[p] == cur!.left!.val
46         {
47             var res:Bool = dfs(cur?.left, voyage)
48             if !res
49             {
50                 return false
51             }
52             return dfs(cur?.right, voyage)
53         }
54         else
55         {
56             fed.append(cur!.val)
57             var res:Bool = dfs(cur?.right, voyage)
58             if !res
59             {
60                 return false
61             }
62             return dfs(cur?.left, voyage)
63         }
64     }
65 }

---

20ms

 

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     var voyage = [Int]()
16     var results = [Int]()
17     var legit = false
18     
19     func flipMatchVoyage(_ root: TreeNode?, _ voyage: [Int]) -> [Int] {
20         self.voyage = voyage
21         self.results = []
22         self.legit = true
23         
24         helper(root, 0, voyage.count)
25         
26         return legit ? results : [-1]
27     }
28     
29     func helper(_ root: TreeNode?, _ start: Int, _ end: Int) -> Int {
30         guard legit else { return 0 }
31         guard let root = root else { 
32             legit = end == start
33             return 0 
34         }
35         guard root.val == voyage[start] else {
36             legit = false
37             return 0
38         }
39         
40         if let l = root.left, let r = root.right {
41             if l.val == voyage[start + 1] {
42                 var i = start + 1
43                 while voyage[i] != r.val && i < end {
44                     i += 1
45                 }
46                 
47                 if i == end {
48                     legit = false
49                     return 0
50                 } else {
51                     return helper(l, start + 1, i) + helper(r, i, end) + 1
52                 }
53             } else if r.val == voyage[start + 1] {
54                 results.append(root.val)
55                 var i = start + 1
56                 while voyage[i] != l.val && i < end {
57                     i += 1
58                 }
59                 
60                 if i == end {
61                     legit = false
62                     return 0
63                 } else {
64                     return helper(r, start + 1, i) + helper(l, i, end) + 1
65                 }
66             } else {
67                 legit = false
68             }
69             
70         } else if let l = root.left {
71             helper(l, start + 1, end) + 1
72         } else if let r = root.right { 
73             helper(r, start + 1, end) + 1
74         } else if end == start + 1 {
75             return 1
76         } else {
77             legit = false
78             return 0
79         }
80         
81         return 0
82     }
83 }

---

24ms

 1 class Solution {
 2     func flipMatchVoyage(_ root: TreeNode?, _ voyage: [Int]) -> [Int] {
 3         var res = [Int]()
 4         if root == nil && voyage.count == 0 {
 5             return []
 6         } else if root == nil && voyage.count != 0 {
 7             return [-1]
 8         } else if root != nil && voyage.count == 0 {
 9             return [-1]
10         } else if root?.val != voyage[0] {
11             return [-1]
12         } else {
13             if root?.left == nil && root?.right == nil {
14                 return []
15             } else if root?.left == nil {
16                 let rvalue = root!.right!.val
17                 let rvoy = cutArray(voyage, rvalue, -1)
18                 let rres = flipMatchVoyage(root!.right, rvoy)
19                 if rres == [-1] {
20                     res = [-1]
21                 } else {
22                     res.append(contentsOf: rres)
23                 }
24             } else if root?.right == nil {
25                 let lvalue = root!.left!.val
26                 let lvoy = cutArray(voyage, lvalue, -1)
27                 let lres = flipMatchVoyage(root!.left, lvoy)
28                 if lres == [-1] {
29                     res = [-1]
30                 } else {
31                     res.append(contentsOf: lres)
32                 }
33             } else {
34                 var ll = root!.left!.val
35                 var rr = root!.right!.val
36                 if ll != voyage[1] {
37                     if rr == voyage[1] {
38                         let node = root?.left
39                         root?.left = root?.right
40                         root?.right = node
41                         res.append(root!.val)
42                     } else {
43                         res = [-1]
44                         return res
45                     }
46                 }
47                 ll = root!.left!.val
48                 rr = root!.right!.val
49                 let lvoy = cutArray(voyage, ll, rr)
50                 let rvoy = cutArray(voyage, rr, -1)
51                 let lres = flipMatchVoyage(root!.left!, lvoy)
52                 let rres = flipMatchVoyage(root!.right!, rvoy)
53                 if lres == [-1] || rres == [-1] {
54                     res = [-1]
55                 } else {
56                     res.append(contentsOf: lres)
57                     res.append(contentsOf: rres)
58                 }
59             }
60         }
61         return res
62     }
63     
64     func cutArray(_ arr: [Int], _ start: Int, _ end: Int) -> [Int] {
65         var res = [Int]()
66         var bb = false
67         for i in arr {
68             if i == start {
69                 bb = true
70             }
71             if i == end {
72                 bb = false
73                 break
74             }
75             if bb {
76                 res.append(i)
77             }
78         }
79         return res
80     }
81 }

---

36ms

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15      func flipMatchVoyage(_ root: TreeNode?, _ voyage: [Int]) -> [Int] {
16         if voyage[0] != root?.val {
17             return [-1]
18         }
19         var index = -1
20         let ans = tryFilp(root!, &index, voyage)
21         return ans.contains(-1) ? [-1] : ans
22     }
23     
24     func tryFilp(_ node: TreeNode?, _ nodeIndex: inout Int, _ voyage: [Int]) -> [Int] {
25         guard let node = node else {
26             return [-1]
27         }
28         nodeIndex += 1
29         if node.val != voyage[nodeIndex] {
30             return [-1]
31         }
32         if node.left == nil && node.right == nil {
33             return []
34         }
35         if node.left != nil || node.right != nil {
36             if node.left != nil {
37                 if node.left?.val != voyage[nodeIndex + 1] {
38                     let temp = node.left
39                     node.left = node.right
40                     node.right = temp
41                     var ans = tryFilp(node.left, &nodeIndex, voyage) + [node.val]
42                     if node.right != nil {
43                         ans += tryFilp(node.right, &nodeIndex, voyage)
44                     }
45                     return ans
46                 } else {
47                     var ans = tryFilp(node.left, &nodeIndex, voyage)
48                     if node.right != nil {
49                         ans += tryFilp(node.right, &nodeIndex, voyage)
50                     }
51                     return ans
52                 }
53             } else {
54                 if node.right?.val != voyage[nodeIndex + 1] {
55                     return [-1]
56                 } else {
57                     return tryFilp(node.right, &nodeIndex, voyage)
58                 }
59             }
60         }
61         return []
62     }
63 }

---

60ms

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public var val: Int
 5  *     public var left: TreeNode?
 6  *     public var right: TreeNode?
 7  *     public init(_ val: Int) {
 8  *         self.val = val
 9  *         self.left = nil
10  *         self.right = nil
11  *     }
12  * }
13  */
14 class Solution {
15     
16     func flipMatchVoyage(_ root: TreeNode?, _ voyage: [Int]) -> [Int] {
17         guard !voyage.isEmpty else { return [-1] }
18         guard root?.val == voyage[0] else { return [-1] }
19         var swaps: [Int] = []
20         var seenDifferentIndices = Set<Int>()
21         
22         while true { 
23             let preorder = preorderTraversal(of: root)
24             
25             if let indexOfDifference = Array(zip(preorder, voyage)).firstIndex(where: { (a, b) in a != b }) {
26                 let differentValue = preorder[indexOfDifference] 
27                 let parent = parentNode(of: differentValue, in: root)!
28                 let left = parent.left
29                 parent.left = parent.right
30                 parent.right = left
31                 swaps.append(parent.val)
32                 
33                 if seenDifferentIndices.contains(indexOfDifference) {
34                     return [-1]
35                 } 
36                 seenDifferentIndices.insert(indexOfDifference) 
37             } else {
38                 break
39             } 
40         }
41         
42         let success = preorderTraversal(of: root) == voyage
43         return success ? swaps : [-1]
44     }
45     
46     private func parentNode(of value: Int, in tree: TreeNode?) -> TreeNode? {
47         guard let tree = tree else { return nil }
48         if tree.left?.val == value || tree.right?.val == value {
49             return tree
50         }
51         
52         return parentNode(of: value, in: tree.left) ?? parentNode(of: value, in: tree.right)
53     }
54     
55     private func preorderTraversal(of tree: TreeNode?) -> [Int] {
56         guard let tree = tree else { return [] }
57         return [tree.val] + preorderTraversal(of: tree.left) + preorderTraversal(of: tree.right)
58     }
59 }