[LeetCode] 687. 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.

Similar with Binary Tree Max Path Sum,  for a given node t, the longest univalue path of this subtree whose root is t, the longest univalue path either includes t or not include t. If not including t, then the answer is either the longest univalue path of t's left subtree or right subtree. If including t, then the answer will be the sum between the left subtree longest straight path and the right subtree longest straight path. 

Solution 1. Naive Recursion.

class Solution {
    public int longestUnivaluePath(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int leftLongestPath = longestUnivaluePath(root.left);
        int rightLongestPath = longestUnivaluePath(root.right);
        int longestPathWithoutCurrentNode = Math.max(leftLongestPath, rightLongestPath);
        int leftLongestSinglePath = longestSinglePath(root.left);
        int rightLongestSinglePath = longestSinglePath(root.right);
        int longestPathWithCurrentNode = 0;
        if(root.left != null && root.left.val == root.val) {
            longestPathWithCurrentNode += (leftLongestSinglePath + 1);
        }
        if(root.right != null && root.right.val == root.val) {
            longestPathWithCurrentNode += (rightLongestSinglePath + 1);
        }      
        return Math.max(longestPathWithoutCurrentNode, longestPathWithCurrentNode);
    }
    private int longestSinglePath(TreeNode node) {
        if(node == null) {
            return 0;
        }
        int leftLongestSinglePath = node.left != null && node.left.val == node.val ? longestSinglePath(node.left) + 1 : 0;
        int rightLongestSinglePath = node.right != null && node.right.val == node.val ? longestSinglePath(node.right) + 1 : 0;
        return Math.max(leftLongestSinglePath, rightLongestSinglePath);
    }
}

The problem with solution is that when computing longest sing path for a subtree, it does not memoize any smaller subtrees' computation result. It always recursively exhaust all nodes of a subtree to get the longest single path. Since each longestSingePath call recursively calls another two longestSinglePath, the runtime for this method alone is O(2^h), where h is the height of a given subtree. 

Solution 2. Recursion with memoization when computing longest single path for a subtree.

class Solution {
    class ResultType {
        int singlePath;
        int maxPath;
        Integer val;
        ResultType(int sp, int mp, Integer v) {
            this.singlePath = sp;
            this.maxPath = mp;
            this.val = v;
        }
    }
    public int longestUnivaluePath(TreeNode root) {
        ResultType result = helper(root);
        return result.maxPath;
    }
    private ResultType helper(TreeNode node) {
        if(node == null) {
            return new ResultType(0, 0, null);
        }
        ResultType left = helper(node.left);
        ResultType right = helper(node.right);
        int singlePath = 0;
        if(left.val != null && left.val == node.val) {
            singlePath = left.singlePath + 1;
        }
        if(right.val != null && right.val == node.val) {
            singlePath = Math.max(singlePath, right.singlePath + 1);
        }
        int maxPathWithoutCurrentNode = Math.max(left.maxPath, right.maxPath);
        int maxPathWithCurrentNode = 0;
        if(left.val != null && left.val == node.val) {
            maxPathWithCurrentNode += (left.singlePath + 1);
        }
        if(right.val != null && right.val == node.val) {
            maxPathWithCurrentNode += (right.singlePath + 1);
        }
        int maxPath = Math.max(maxPathWithoutCurrentNode, maxPathWithCurrentNode);
        return new ResultType(singlePath, maxPath, node.val);
    }
}

Solution 3. A cleaner implementation with the same memoization idea

class Solution {
    int ans = 0;
    public int longestUnivaluePath(TreeNode root) {
        helper(root);
        return ans;
    }
    private int helper(TreeNode node) {
        if(node == null) {
            return 0;
        }
        int leftMaxPath = helper(node.left);
        int rightMaxPath = helper(node.right);
        int leftMaxPathWithCurrentNode = node.left != null && node.left.val == node.val ? leftMaxPath + 1 : 0;
        int rightMaxPathWithCurrentNode = node.right != null && node.right.val == node.val ? rightMaxPath + 1 : 0;
        ans = Math.max(ans, leftMaxPathWithCurrentNode + rightMaxPathWithCurrentNode);
        return Math.max(leftMaxPathWithCurrentNode, rightMaxPathWithCurrentNode);
    }
}