298. Binary Tree Longest Consecutive Sequence

題目：

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

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.

鏈接： http://leetcode.com/problems/binary-tree-longest-consecutive-sequence/

題解：

求二叉樹中最長連續序列。 題目又比較長， 不過我們可以確定這個最長連續序列肯定是遞增的，比如123，或者345。知道這點以后就可以用DFS遍歷了。

Time Complexity - O(n)，  Space Complexity - O(n)。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private int max = 0;
    public int longestConsecutive(TreeNode root) {
        if(root == null) {
            return max;
        }
        findLongestConsecutive(root, 0, root.val);
        return max;
    }
    
    private void findLongestConsecutive(TreeNode root, int curMax, int target) {
        if(root == null) {
            return;
        }
        if(root.val == target) {
            curMax++;
        } else {
            curMax = 1;
        }
        max = Math.max(max, curMax);
        findLongestConsecutive(root.left, curMax, root.val + 1);
        findLongestConsecutive(root.right, curMax, root.val + 1);
    }
}

 

二刷:

根據題目的意思，最長連續子序列必須是從root到leaf的方向。 比如 1->2，那么我們就返回長度2， 比如1->3->4->5，我們就返回3->4->5這個子序列的長度3。把樹遍歷一遍就可以得到結果了。

方法和一刷一樣，構建一個輔助方法，形參是當前要處理的節點root，root父節點的值lastVal，以及當前的長度curLen。也要使用一個global variable maxLen來保存全局最大長度。也有使用stack來iterative遍歷的做法。

Java:

Time Complexity - O(n)，  Space Complexity - O(n)。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private int maxLen = 0;
    
    public int longestConsecutive(TreeNode root) {
        longestConsecutive(root, 0, 0);
        return maxLen;
    }
    
    private void longestConsecutive(TreeNode root, int lastVal, int curLen) {
        if (root == null) return;
        if (root.val != lastVal + 1) curLen = 1;
        else curLen++;
        maxLen = Math.max(maxLen, curLen);
        longestConsecutive(root.left, root.val, curLen);
        longestConsecutive(root.right, root.val, curLen);
    }
}

 

Reference:

https://leetcode.com/discuss/68723/simple-recursive-dfs-without-global-variable

https://leetcode.com/discuss/66486/c-solution-in-4-lines

https://leetcode.com/discuss/66565/1ms-easy-understand-java-solution-just-traverse-the-tree-once

https://leetcode.com/discuss/68094/dont-understand-what-is-consecutive-sequence

https://leetcode.com/discuss/66646/two-simple-iterative-solutions-bfs-and-dfs

https://leetcode.com/discuss/66548/recursive-solution-bottom-iteration-solution-using-stack

https://leetcode.com/discuss/66584/easy-java-dfs-is-there-better-time-complexity-solution