[LeetCode] 549. Binary Tree Longest Consecutive Sequence II

Problem

Given a binary tree, you need to find the length of Longest Consecutive Path in Binary Tree.

Especially, this path can be either increasing or decreasing. For example, [1,2,3,4] and [4,3,2,1] are both considered valid, but the path [1,2,4,3] is not valid. On the other hand, the path can be in the child-Parent-child order, where not necessarily be parent-child order.

Example 1:
Input:

    1
   / \
  2   3

Output: 2
Explanation: The longest consecutive path is [1, 2] or [2, 1].
Example 2:
Input:

    2
   / \
  1   3

Output: 3
Explanation: The longest consecutive path is [1, 2, 3] or [3, 2, 1].
Note: All the values of tree nodes are in the range of [-1e7, 1e7].

Solution

class Solution {
    private int maxLen = 0;
    public int longestConsecutive(TreeNode root) {
        //use recursion for tree 
        //should maintain two variables: increasing/decreasing sequence lengths
        helper(root);
        return maxLen;
    }
    private int[] helper(TreeNode root) {
        //terminate condition
        if (root == null) return new int[]{0, 0};
        
        //do recursion
        int[] left = helper(root.left);
        int[] right = helper(root.right);
        
        //update increasing/decreasing sequence lengths: inc/dec
        int inc = 1, dec = 1;
        if (root.left != null) {
            if (root.left.val == root.val-1) inc = left[0]+1;
            if (root.left.val == root.val+1) dec = left[1]+1;
        }
        if (root.right != null) {
            if (root.right.val == root.val-1) inc = Math.max(inc, right[0]+1);
            if (root.right.val == root.val+1) dec = Math.max(dec, right[1]+1);
        }
        
        //update max length: maxLen
        maxLen = Math.max(maxLen, inc+dec-1);
        
        //pass in inc/dec into higher level recursion
        return new int[]{inc, dec};
    }
}