Binary Tree Longest Consecutive Sequence II

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].

思路：这题跟 Binary Tree Longest Consecutive Sequence  不一样的地方在于，他可以连起来，左边和右边都可以连起来；那么我们就要想到 divide and conquer的解法，就是返回以当前node为起点的increase和decrease的长度，然后往上返回的信息就是一个自定义的结构，这个结构包含，increase和decrease还有下面返回上来的longestLength；最后当前的longestLength为curInc + curDec + 1，和左右两边的longestLength取最大值；

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public class Node {
        public int inc;
        public int dec;
        public int longest;
        public Node(int inc, int dec, int longest) {
            this.inc = inc;
            this.dec = dec;
            this.longest = longest;
        }
    }
    
    public int longestConsecutive(TreeNode root) {
        if(root == null) {
            return 0;
        }
        Node res = dfs(root);
        return res.longest;
    }
    
    private Node dfs(TreeNode root) {
        if(root == null) {
            return new Node(0, 0, 0);
        }
        Node leftnode = dfs(root.left);
        Node rightnode = dfs(root.right);
        int inc = 0;
        int dec = 0;
        int longest = 0;
        if(root.left != null) {
            if(root.val + 1 == root.left.val) {
                inc = Math.max(inc, leftnode.inc + 1);
            }
            if(root.val - 1 == root.left.val) {
                dec = Math.max(dec, leftnode.dec + 1);
            }
        }
        
        if(root.right != null) {
            if(root.val + 1 == root.right.val) {
                inc = Math.max(inc, rightnode.inc + 1);
            }
            if(root.val - 1 == root.right.val) {
                dec = Math.max(dec, rightnode.dec + 1);
            }
        }
        
        longest = Math.max(inc + 1 + dec, Math.max(leftnode.longest, rightnode.longest));
        return new Node(inc, dec, longest);
    }
}