LeetCode每日一题(971. Flip Binary Tree To Match Preorder Traversal)

You are given the root of a binary tree with n nodes, where each node is uniquely assigned a value from 1 to n. You are also given a sequence of n values voyage, which is the desired pre-order traversal of the binary tree.

Any node in the binary tree can be flipped by swapping its left and right subtrees. For example, flipping node 1 will have the following effect:

Flip the smallest number of nodes so that the pre-order traversal of the tree matches voyage.

Return a list of the values of all flipped nodes. You may return the answer in any order. If it is impossible to flip the nodes in the tree to make the pre-order traversal match voyage, return the list [-1].

Example 1:

Input: root = [1,2], voyage = [2,1]
Output: [-1]
Explanation: It is impossible to flip the nodes such that the pre-order traversal matches voyage.

Example 2:

Input: root = [1,2,3], voyage = [1,3,2]
Output: [1]
Explanation: Flipping node 1 swaps nodes 2 and 3, so the pre-order traversal matches voyage.

Example 3:

Input: root = [1,2,3], voyage = [1,2,3]
Output: []
Explanation: The tree’s pre-order traversal already matches voyage, so no nodes need to be flipped.

Constraints:

• The number of nodes in the tree is n.
• n == voyage.length
• 1 <= n <= 100
• 1 <= Node.val, voyage[i] <= n
• All the values in the tree are unique.
• All the values in voyage are unique.

---

用 preorder 来遍历树， 同时跟 vayage 进行对比， 如果左边节点的值与 voyage 的下一个值相等则用左边节点进行下一步的遍历， 如果右边节点的值与 voyage 的下一个值相等， 那就用右边的节点进行下一步的遍历。但是如果需要用右边节点进行遍历则证明左右两边节点需要互换，所以当前节点的值需要加到答案数组里。

---

use std::cell::RefCell;
use std::rc::Rc;

impl Solution {
    
    fn rc(root: Option<Rc<RefCell<TreeNode>>>, voyage: &mut Vec<i32>) -> Vec<i32> {
    
        if let Some(node) = root {
    
            let v = voyage.remove(0);
            if node.borrow().val != v {
    
                return vec![-1];
            }
            let left = node.borrow_mut().left.take();
            let right = node.borrow_mut().right.take();
            let left_val = if let Some(l) = &left {
    
                l.borrow().val
            } else {
    
                -1
            };
            let right_val = if let Some(r) = &right {
    
                r.borrow().val
            } else {
    
                -1
            };
            if left_val == -1 && right_val == -1 {
    
                return vec![];
            }
            if left_val == voyage[0] {
    
                let mut l = Solution::rc(left, voyage);
                if l == vec![-1] {
    
                    return vec![-1];
                }
                let mut r = Solution::rc(right, voyage);
                if r == vec![-1] {
    
                    return vec![-1];
                }
                l.append(&mut r);
                return l;
            }
            let mut l = Solution::rc(right, voyage);
            if l == vec![-1] {
    
                return vec![-1];
            }
            let mut r = Solution::rc(left, voyage);
            if r == vec![-1] {
    
                return vec![-1];
            }
            l.append(&mut r);
            if left_val != -1 {
    
                l.push(node.borrow().val);
            }
            return l;
        }
        vec![]
    }
    pub fn flip_match_voyage(
        root: Option<Rc<RefCell<TreeNode>>>,
        mut voyage: Vec<i32>,
    ) -> Vec<i32> {
    
        Solution::rc(root, &mut voyage)
    }
}