> For the complete documentation index, see [llms.txt](https://protegejj.gitbook.io/my-algorithm-summary/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://protegejj.gitbook.io/my-algorithm-summary/data-structure/tree/549-binary-tree-longest-consecutive-sequence-ii.md).

# 549 Binary Tree Longest Consecutive Sequence II

## 549. Binary Tree Longest Consecutive Sequence II

## 1. Question

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

## 2. Implementation

**(1) DFS**

思路：对于每个node,我们分别找出它的左子树和右子树中最长的increasing consecutive sequence的长度和decreasing consecutive sequence的长度, 然后这两个长度加起来减一(该node被重复算了一次)，则是穿过这个node的最长consecutive sequence，通过这个方法，递归地遍历每个node可以得到最后的结果

```java
class Solution {
    public int longestConsecutive(TreeNode root) {
        int[] max = new int[1];
        dfs(root, max);
        return max[0];
    }

    public int[] dfs(TreeNode node, int[] max) {
        if (node == null) {
            return new int[] {0, 0};
        }

        int decrease = 1, increase = 1;

        if (node.left != null) {
            int[] left = dfs(node.left, max);
            if (node.val - 1 == node.left.val) {
                decrease = left[0] + 1;
            }
            else if (node.val + 1 == node.left.val) {
                increase = left[1] + 1;
            }
        }

        if (node.right != null) {
            int[] right = dfs(node.right, max);
            if (node.val - 1 == node.right.val) {
                decrease = Math.max(decrease, right[0] + 1);
            }
            else if (node.val + 1 == node.right.val) {
                increase = Math.max(increase, right[1] + 1);
            }
        }

        max[0] = Math.max(max[0], decrease + increase - 1);
        return new int[] {decrease, increase};
    }
}
```

## 3. Time & Space Complexity

DFS: 时间复杂度: O(n), 空间复杂度: O(n)