具有所有最深节点的最小子树(Java)

给定一个根为 root 的二叉树，每个节点的深度是该节点到根的最短距离 。如果一个节点在整个树的任意节点之间具有最大的深度，则该节点是最深的。
一个节点的子树 是该节点加上它的所有后代的集合。返回能满足以该节点为根的子树中包含所有最深的节点这一条件的具有最大深度的节点。

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4]
输出：[2,7,4]
解释：
我们返回值为 2 的节点，在图中用黄色标记。
在图中用蓝色标记的是树的最深的节点。
注意，节点 5、3 和 2 包含树中最深的节点，但节点 2 的子树最小，因此我们返回它。

示例 2：
输入：root = [1]
输出：[1]
解释：根节点是树中最深的节点。

示例 3：
输入：root = [0,1,3,null,2]
输出：[2]
解释：树中最深的节点为 2 ，有效子树为节点 2、1 和 0 的子树，但节点 2 的子树最小。

提示：
树中节点的数量介于 1 和?500 之间。
0 <= Node.val <= 500
每个节点的值都是独一无二的。

package om.loo;

import java.util.HashMap;
import java.util.Map;

public class DepthMinTree {
    
    public static Map<TreeNode , Integer> depth = null;
    public static int maxDepth = 0;
    public static Map<TreeNode , Integer> depth3 = new HashMap<TreeNode , Integer>();

    public static void main(String[] args) {
        TreeNode rootA = new TreeNode(3);
        TreeNode leftA1 = new TreeNode(5);
        TreeNode rightA1 = new TreeNode(1);
        TreeNode leftA2 = new TreeNode(6);
        TreeNode leftA3 = new TreeNode(2);
        TreeNode rightA2 = new TreeNode(0);
        TreeNode rightA3 = new TreeNode(8);
        TreeNode leftA4 = new TreeNode(7);
        TreeNode leftA5 = new TreeNode(4);
        rootA.left = leftA1;
        rootA.right = rightA1;
        leftA1.left = leftA2;
        leftA1.right = leftA3;
        rightA1.left = rightA2;
        rightA1.right = rightA3;
        leftA3.left = leftA4;
        leftA3.right = leftA5;
        TreeNode node = getDepthMinTree4(rootA);
        printTreeNode(node);
        
    }
    
    /*
    先做一次深度优先搜索标记所有节点的深度来找到最深的节点，再做一次深度优先搜索用回溯法找最小子树。定义第二次深度优先搜索方法为 getMinTreeNode(node)，每次递归有以下四种情况需要处理：
  如果 node 没有左右子树，返回 node。
  如果 node 左右子树的后代中都有最深节点，返回 node。
  如果只有左子树或右子树中有且拥有所有的最深节点，返回这棵子树的根节点（即 node 的左/右孩子）。
  否则，当前子树中不存在答案。
    */
    public static TreeNode getDepthMinTree(TreeNode root) {
        depth = new HashMap<TreeNode , Integer>();
        depth.put(null, -1);
        dfs(root , null);
        maxDepth = -1;
        for (Integer i : depth.values()) {
            maxDepth = Math.max(maxDepth, i);
        }
        return getMinTreeNode(root);
    }
    
    public static void dfs(TreeNode node , TreeNode parent) {
        if (node!=null) {
            depth.put(node, depth.get(parent)+1);
            dfs(node.left , node);
            dfs(node.right , node);
        }
    }
    
    public static TreeNode getMinTreeNode(TreeNode root) {
        if (root == null || depth.get(root) == maxDepth) {
            return root;
        }
        TreeNode left = getMinTreeNode(root.left);
        TreeNode right = getMinTreeNode(root.right);
        if (left!=null && right!=null) {
            return root;
        }
        if (left!=null) {
            return left;
        }
        if (right!=null) {
            return right;
        }
        return null;
    }
    
    public static TreeNode getDepthMinTree2(TreeNode root) {
        return dfs2(root).node;
    }
    
    public static R dfs2(TreeNode node) {
        if (node == null) {
            return new R(null , 0);
        }
        R left = dfs2(node.left);
        R right = dfs2(node.right);
        if (left.dist>right.dist) {
            return new R(left.node , left.dist + 1);
        } else if (left.dist < right.dist) {
            return new R(right.node , right.dist + 1);
        }
        return new R(node , left.dist + 1);
    }
    /*
    用一个map记录所有节点的深度。从根节点开始,如果左右子树的深度一致,直接返回根节点。否则递归判断深度较大的子树。
    */
    public static TreeNode getDepthMinTree3(TreeNode root) {
        if (root == null) {
            return null;
        }
        int left = getDepth(root.left);
        int right = getDepth(root.right);
        if (left == right) {
            return root;
        } else if (left>right) {
            return getDepthMinTree3(root.left);
        } else {
            return getDepthMinTree3(root.right);
        }
    }
    
    public static int getDepth(TreeNode node) {
        if (node == null) {
            return 0;
        }
        if (depth3.containsKey(node)) {
            return depth3.get(node);
        }
        int left = getDepth(node.left);
        int right = getDepth(node.right);
        depth3.put(node, Math.max(left, right) + 1);
        return depth3.get(node);
    }
    
    public static TreeNode getDepthMinTree4(TreeNode root) {
        if (root == null) {
            return null;
        }
        int left = dfs4(root.left);
        int right = dfs4(root.right);
        if (left == right) {
            return root;
        } else if (left > right) {
            return getDepthMinTree4(root.left);
        }
        return getDepthMinTree4(root.right);
    }
    
    public static int dfs4(TreeNode node) {
        if (node == null) {
            return 0;
        }
        return 1 + Math.max(dfs4(node.left), dfs4(node.right));
    }
    
    public static void printTreeNode(TreeNode root) {
        if (root!=null) {
            System.out.println(root.value);
            printTreeNode(root.left);
            printTreeNode(root.right);
        }
    }
    
    static class TreeNode {
        int value;
        TreeNode left;
        TreeNode right;
        TreeNode(int v) {
            value = v;
        }
    }
    
    static class R {
        TreeNode node;
        int dist;
        R(TreeNode n , int d) {
            node = n;
            dist = d;
        }
    }

}