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

链接：https://leetcode.com/problems/binary-tree-longest-consecutive-sequence-ii/#/description

5/10/2017

算法班，自己有思路，但是没有做出来，不知道是思路问题还是代码问题

注意问题：

1. 多个返回值需要判断，可以返回int array或者object

2. main function里不要重复定义maxLength

3. 第29，33行的判断需要把左右的都包括进去，不要覆盖了来自于left的最大值。或者第18，21行用同样的计算来统一。

4. 宁可把当前层的变量和返回值分开，不要随便合起来用，思路容易混。

这个解法是Bottom up，时间复杂度O(n)，也是post-order traversal。

思考：是否post-order traversal的做法就是bottom up呢？应该是的吧

这种post-order traversal步骤：

1. 判断特殊null情况

2. 左右子树调用，并返回值

3. 做当前层的判断处理。

public class Solution {
    int maxLength = 0;
    public int longestConsecutive(TreeNode root) {
        if (root == null) return 0;
        longestPath(root);
        return maxLength;
    }
    private int[] longestPath(TreeNode root) {
        if (root == null) {
            // return type [increase, decrease]
            return new int[]{0,0};
        }
        int tmpIncrease = 1, tmpDecrease = 1;
        if (root.left != null) {
            int[] leftFlags = longestPath(root.left);
            if (root.val + 1 == root.left.val) {
                // increase
                tmpIncrease = leftFlags[0] + 1;
            } else if (root.val - 1 == root.left.val) {
                // decrease
                tmpDecrease = leftFlags[1] + 1;
            }
        }
        if (root.right != null) {
            int[] rightFlags = longestPath(root.right);
            if (root.val + 1 == root.right.val) {
                // increase
                // do not override left part max value
                tmpIncrease = Math.max(rightFlags[0] + 1, tmpIncrease);
            } else if (root.val - 1 == root.right.val) {
                // decrease
                // do not override left part max value
                tmpDecrease = Math.max(rightFlags[1] + 1, tmpDecrease);
            }
        }
        maxLength = Math.max(tmpIncrease + tmpDecrease - 1, maxLength);
        return new int[]{tmpIncrease, tmpDecrease};
    }
}

参考链接：

https://discuss.leetcode.com/topic/85764/neat-java-solution-single-pass-o-n

https://discuss.leetcode.com/topic/85745/java-solution-binary-tree-post-order-traversal

更多讨论：

https://discuss.leetcode.com/category/705/binary-tree-longest-consecutive-sequence-ii