給定一個有 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]

code

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
private:
    int i = 0;
private:
    
 
void dfs(TreeNode* root, const vector<int>& voyage, vector<int> &res, bool &flag) {
        if(root == NULL || flag) {
            return ;
        }

        if(root->val != voyage[i]) {
            flag = true;
            return ;
        }

        if(root->left != NULL && root->left->val != voyage[i+1
 
]) {
            TreeNode *tmp = root->left;
            root->left = root->right;
            root->right = tmp;
            res.push_back(root->val);
        }

        ++i;
        dfs(root->left, voyage, res, flag);
        dfs(root->right, voyage, res, flag);
    }
public:
    vector<int> flipMatchVoyage(TreeNode* root, vector<int>& voyage) {
        if(root == NULL || voyage.empty()) {
            return {};
        }

        vector<int> res;
        bool flag = false;
        dfs(root, voyage, res, flag);
        if(flag) {
            return {-1};
        }
        return res;
    }
};