package jjn.carl.binary_tree;
import commons.BinaryTreeHelper;
import commons.TreeNode;
import java.util.ArrayList;
import java.util.List;
/**
 * @author Jiang Jining
 * @since 2023-07-16 10:10
 */
public class LeetCode513 {
    private int maxDepth = -1;
    private int bottomLeftValue;
    public int findBottomLeftValue(TreeNode root) {
        traversal(root, 0);
        return bottomLeftValue;
    }
    private void traversal(TreeNode node, int depth) {
        if (node.left == null && node.right == null) {
            if (depth > maxDepth) {
                maxDepth = depth;
                bottomLeftValue = node.val;
            }
            return;
        }
        if (node.left != null) {
            traversal(node.left, depth + 1);
        }
        if (node.right != null) {
            traversal(node.right, depth + 1);
        }
    }
    public static void main(String[] args) {
        List<Integer> input = new ArrayList<>(List.of(1));
        TreeNode node = BinaryTreeHelper.buildTree(input);
        int bottomLeftValue = new LeetCode513().findBottomLeftValue(node);
        System.out.println("bottomLeftValue = " + bottomLeftValue);
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    private boolean canReach;
    public boolean hasPathSum(TreeNode root, int targetSum) {
        dfs(root, targetSum, 0);
        return canReach;
    }
    private void dfs(TreeNode node, int targetSum, int currentSum) {
        if(node == null) {
            return;
        }
        if(node.left == null && node.right == null) {
            if(currentSum + node.val == targetSum) {
                canReach = true;
            }
            return;
        }
        if(node.left != null) {
            dfs(node.left, targetSum, currentSum + node.val);
        }
        if(node.right != null) {
            dfs(node.right, targetSum, currentSum + node.val);
        }
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>> result = new ArrayList<>();
        backtrack(result, root, new ArrayList<>(), targetSum, 0);
        return result;
    }
    private void backtrack(List<List<Integer>> result, TreeNode root, List<Integer> path, int targetSum, int currentSum) {
        if(root == null) {
            return;
        }
        path.add(root.val);
        if(root.left == null && root.right == null) {
            if(currentSum + root.val == targetSum) {
                result.add(new ArrayList<>(path));   
            }
            return;
        }
        if(root.left != null) {
            backtrack(result, root.left, path, targetSum, currentSum + root.val);
             path.remove(path.size()- 1);
        }
        if(root.right != null) {
            backtrack(result, root.right, path, targetSum, currentSum + root.val);
             path.remove(path.size()- 1);
        }
    }
 }

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    Map<Integer, Integer> map;  // 方便根据数值查找位置
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        map = new HashMap<>();
        for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
            map.put(inorder[i], i);
        }
        return findNode(inorder,  0, inorder.length, postorder,0, postorder.length);  // 前闭后开
    }
    public TreeNode findNode(int[] inorder, int inBegin, int inEnd, int[] postorder, int postBegin, int postEnd) {
        // 参数里的范围都是前闭后开
        if (inBegin >= inEnd || postBegin >= postEnd) {  // 不满足左闭右开，说明没有元素，返回空树
            return null;
        }
        int rootIndex = map.get(postorder[postEnd - 1]);  // 找到后序遍历的最后一个元素在中序遍历中的位置
        TreeNode root = new TreeNode(inorder[rootIndex]);  // 构造结点
        int lenOfLeft = rootIndex - inBegin;  // 保存中序左子树个数，用来确定后序数列的个数
        root.left = findNode(inorder, inBegin, rootIndex,
                            postorder, postBegin, postBegin + lenOfLeft);
        root.right = findNode(inorder, rootIndex + 1, inEnd,
                            postorder, postBegin + lenOfLeft, postEnd - 1);
        return root;
    }
}