二叉树：最长相同值路径

    给定一棵二叉树，求其有相同值的最长路径长度。如下面的二叉树，最长相同值的路径是4-4-4，其路径长度为2。

    分析：可以采用递归方法，递归返回与当前值相同的左右子树的最长相同值路径长度。同时，对该节点的最长相同值路径长度进行判断，分三种情况：

    1. root.val = root.left.val = root.right.val，此时需要把左子树和右子树返回的最长相同值路径长度相加，再加上2，作为当前节点的最长相同值路径；

    2.root.val = root.left.val 或者root.val = root.right.val，此时当前节点的最长相同路径为左子树或右子树的最长相同路径长度 + 1；

    3.root.val与左右儿子节点都不相同，当前节点的最长相同路径长度为0。

    private int maxLength = 0;    //记录最长路径长度
    public int longestUnivaluePath(TreeNode root) {
        length(root);
        return maxLength;
    }
    public int length(TreeNode root){
        if(root == null)
            return 0;
        int leftLength = length(root.left);
        int rightLength = length(root.right);
        int length = 0;
        if(root.left != null && root.right != null && root.val == root.left.val && root.val == root.right.val){
            length = Math.max(leftLength, rightLength) + 1;
            maxLength = Math.max(leftLength + rightLength + 2,  maxLength); //可能更新maxLength
        }
        else{
            length = root.left != null && root.val == root.left.val ? leftLength + 1 : length;
            length = root.right != null && root.val == root.right.val ? rightLength + 1 : length;
            maxLength = Math.max(length, maxLength);    //可能更新maxLength
        }
        return length;
    }

    相同的思路，可以对上面代码进行简化：

class Solution {
    public int longestUnivaluePath(TreeNode root) {
        int[] res = new int[1];    //使用数组，用于参数传递，避免全局变量
        if (root != null) dfs(root, res);
        return res[0];
    }

    private int dfs(TreeNode node, int[] res) {
        int l = node.left != null ? dfs(node.left, res) : 0; // Longest-Univalue-Path-Start-At - left child
        int r = node.right != null ? dfs(node.right, res) : 0; // Longest-Univalue-Path-Start-At - right child
        int resl = node.left != null && node.left.val == node.val ? l + 1 : 0; // Longest-Univalue-Path-Start-At - node, and go left
        int resr = node.right != null && node.right.val == node.val ? r + 1 : 0; // Longest-Univalue-Path-Start-At - node, and go right
        res[0] = Math.max(res[0], resl + resr); // Longest-Univalue-Path-Across - node
        return Math.max(resl, resr);
    }
}