Longest Univalue Path

Given a binary tree, find the length of the longest path where each node in the path has the same value. This path may or may not pass through the root.

Note: The length of path between two nodes is represented by the number of edges between them.

Example 1:

Input:

              5
             / \
            4   5
           / \   \
          1   1   5

 

Output:

2

 

Example 2:

Input:

              1
             / \
            4   5
           / \   \
          4   4   5

 

Output:

2

 

Note: The given binary tree has not more than 10000 nodes. The height of the tree is not more than 1000.

思路：recursion，弄懂向上返回的意义是跟当前root.val相等的path+1，遍历tree的时候，收集最大值即可。注意传参数用array。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
     
    public int longestUnivaluePath(TreeNode root) {
       int[] array = {0};
       findHelper(root, array);
       return array[0];
    }
    
    public int findHelper(TreeNode root, int[] array) {
         if(root == null || (root.left == null && root.right == null)) {
            return 0;
        } else {
            int leftmax = 0;
            int rightmax = 0;
            int localmax = 0;
            if(root.left != null) {
                leftmax = findHelper(root.left, array);
                if(root.val == root.left.val){
                    leftmax += 1;
                    localmax = Math.max(localmax, leftmax);
                } 
            }
            if(root.right != null ){
                rightmax = findHelper(root.right, array);
                if(root.val == root.right.val){
                    rightmax += 1;
                    localmax = Math.max(localmax, rightmax);
                } 
            }
            
            int temp = 0;
            if(root.left != null && root.right != null 
               && root.val == root.left.val
               && root.val == root.right.val){
                temp = leftmax + rightmax;
            }
            array[0] = Math.max(temp, Math.max(localmax, array[0]));
            return localmax;  
        }
    }
}