Given a binary tree, find the length of the longest consecutive sequence path.

The path refers to any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The longest consecutive path need to be from parent to child (cannot be the reverse).

Example

For example,

   1
         3
    /    2   4
                 5

Longest consecutive sequence path is 3-4-5, so return 3.

   2
         3
    / 
   2    
  / 
 1

Longest consecutive sequence path is 2-3,not3-2-1, so return 2.

它這裏的consecutive意思是數字一定要連續+1.

用分治法 + 全局變量監控。左邊增加長度要求root.val + 1 == root.left.val 。同時要註意如果某個點發生了斷層，要重新開始計數。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */


public class Solution {
    /*
     * @param root: the root of binary tree
     * @return: the length of the longest consecutive sequence path
     
 
*/
     
    private int maxConsec = Integer.MIN_VALUE;
    
    public int longestConsecutive(TreeNode root) {
        // write your code here
        helper(root);
        return maxConsec;
    }
    
    private int helper(TreeNode root) {
        if (root == null) {
            return 0;
        }
        
        int left = helper(root.left);
        int right = helper(root.right);
        
        int crtLeft = Integer.MIN_VALUE;
        int crtRight = Integer.MIN_VALUE;

        if (root.left != null && root.val + 1 == root.left.val) {
            crtLeft = 1 + left;
        } 
        // 註意這裏的處理。如果發生斷層不連續了，這條路往上就不能用之前的繼續計數了。
        else {
            crtLeft = 1;
        }
        
        if (root.right != null && root.val + 1 == root.right.val) {
            crtRight = 1 + right;
        } else {
            crtRight = 1;
        }
        
        int crtMax = Math.max(crtLeft, crtRight);
        if (crtMax > maxConsec) {
            maxConsec = crtMax;
        }
        return crtMax;
    }
}

九章算法的：

想到除了null別的點起碼都是1，從而節省了代碼空間。

// version 2: Another Traverse + Divide Conquer 
public class Solution {
    private int longest;
    
    /**
     * @param root the root of binary tree
     * @return the length of the longest consecutive sequence path
     */
    public int longestConsecutive(TreeNode root) {
        longest = 0;
        helper(root);
        return longest;
    }
    
    private int helper(TreeNode root) {
        if (root == null) {
            return 0;
        }
        
        int left = helper(root.left);
        int right = helper(root.right);
        
        int subtreeLongest = 1; // at least we have root
        if (root.left != null && root.val + 1 == root.left.val) {
            subtreeLongest = Math.max(subtreeLongest, left + 1);
        }
        if (root.right != null && root.val + 1 == root.right.val) {
            subtreeLongest = Math.max(subtreeLongest, right + 1);
        }
        
        if (subtreeLongest > longest) {
            longest = subtreeLongest;
        }
        return subtreeLongest;
    }
}

lintcode595- Binary Tree Longest Consecutive Sequence- easy