let112

//给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和
// targetSum 。如果存在，返回 true ；否则，返回 false 。 
//
// 叶子节点 是指没有子节点的节点。 
//
// 
//
// 示例 1： 
// 
// 
//输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
//输出：true
//解释：等于目标和的根节点到叶节点路径如上图所示。
// 
//
// 示例 2： 
// 
// 
//输入：root = [1,2,3], targetSum = 5
//输出：false
//解释：树中存在两条根节点到叶子节点的路径：
//(1 --> 2): 和为 3
//(1 --> 3): 和为 4
//不存在 sum = 5 的根节点到叶子节点的路径。 
//
// 示例 3： 
//
// 
//输入：root = [], targetSum = 0
//输出：false
//解释：由于树是空的，所以不存在根节点到叶子节点的路径。
// 
//
// 
//
// 提示： 
//
// 
// 树中节点的数目在范围 [0, 5000] 内 
// -1000 <= Node.val <= 1000 
// -1000 <= targetSum <= 1000 
// 
//
// Related Topics 树 深度优先搜索 广度优先搜索 二叉树 👍 1074 👎 0


//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool ValueSum(TreeNode *root, int sum) {
        //现在让我们确定递归的结束的条件
        if (root->left == NULL && root->right == NULL && sum == 0) {
            return true;
        }
        if (root->left == NULL && root->right == NULL && sum != 0) {
            return false;
        }
        //开始我们每一层的逻辑
        if (root->left) {
            sum -= root->left->val;
            if (ValueSum(root->left, sum)) {
                return true;

            }
            sum += root->left->val;
        }
        if (root->right) {
            sum -= root->right->val;
            if (ValueSum(root->right, sum)) {
                return true;

            }
            sum += root->right->val;
        }
        return false;


    }

    bool hasPathSum(TreeNode *root, int targetSum) {
        if (root == NULL) {
            return false;
        }
        return ValueSum(root, targetSum - root->val);


    }
};
//leetcode submit region end(Prohibit modification and deletion)

//给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并
//返回这颗 二叉树 。 
//
// 
//
// 示例 1: 
// 
// 
//输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
//输出：[3,9,20,null,null,15,7]
// 
//
// 示例 2: 
//
// 
//输入：inorder = [-1], postorder = [-1]
//输出：[-1]
// 
//
// 
//
// 提示: 
//
// 
// 1 <= inorder.length <= 3000 
// postorder.length == inorder.length 
// -3000 <= inorder[i], postorder[i] <= 3000 
// inorder 和 postorder 都由 不同 的值组成 
// postorder 中每一个值都在 inorder 中 
// inorder 保证是树的中序遍历 
// postorder 保证是树的后序遍历 
// 
//
// Related Topics 树 数组 哈希表 分治 二叉树 👍 904 👎 0


//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode *traversal(vector<int> &inorder, vector<int> &postorder) {
        //递归的写法，我们首先就是要确认的就是我们的递归的终止的条件
        if (postorder.size() == 0) {
            //这个就说明我们的后序遍历的数组其实是空的
            // 我们这个时候我们其实是可以认为我们的
            //我们的前序遍历的数组其实就是空的
            return NULL;
        }
        //这里我们就将我们后续遍历数组的最后一个的值来当做我们的前序遍历的分割数组
        int lastValue = postorder[postorder.size() - 1];
        TreeNode *rootNode = new TreeNode(lastValue);
        //叶子节点
        if (postorder.size() == 1) {
            return rootNode;
        }
        //找到中序遍历的切割点
        int deliIndex;
        for (deliIndex = 0; deliIndex < inorder.size(); ++deliIndex) {
            if (inorder[deliIndex] == lastValue) {
                break;
            }
        }
        //我们接下来就是要切割我们的中序的数组
        //我们在这里的切割的原则就是左闭右开

        vector<int> leftInorder(inorder.begin(), inorder.begin() + deliIndex);
        vector<int> rightInorder(inorder.begin() + deliIndex + 1, inorder.end());
        //删除我们的末尾的元素
        postorder.resize(postorder.size() - 1);

        //然后就是切割我们的后续数组
        vector<int> leftPostOrder(postorder.begin(), postorder.begin() + leftInorder.size());
        vector<int> rightPostOrder(postorder.begin() + leftInorder.size(), postorder.end());
        rootNode->left = traversal(leftInorder, leftPostOrder);
        rootNode->right = traversal(rightInorder, rightPostOrder);

        return rootNode;

    }

    TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
        //
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder, postorder);
    }
};
//leetcode submit region end(Prohibit modification and deletion)