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

## Example

**Example 1:**

```
Input:
   1
    \
     3
    / \
   2   4
        \
         5

Output: 3
Explanation: 
Longest consecutive sequence path is 
3-4-5, so return 3.
```

**Example 2:**

```
Input:
   2
    \
     3
    / 
   2    
  / 
 1

Output: 2 

Explanation: 
Longest consecutive sequence path is 2-3, not 3-2-1, so return 2.
```

## Note

这里需要一个全局变量记录最大值。

遍历或者分治都可以解决问题。

遍历：

前序遍历，需要parent指针进行prev的判断，连续就累加长度，维护res为最大的len

分治：

后序遍历，满足连续条件，根比左/右小一，则左右子树的返回值加上1，同样维护最大的len

## Code

```java
class Solution {
    private int res;
    public int longestConsecutive(TreeNode root) {
        res = 0;
        dfs(root, null, 0);

        return res;
    }

    private void dfs(TreeNode root, TreeNode parent, int len) {
        if (root == null) {
            return;
        }

        if (parent == null || parent.val + 1 == root.val) {
            len++;
        } else {
            len = 1;
        }

        res = Math.max(res, len);

        dfs(root.left,  root, len);
        dfs(root.right, root, len);
    }
}
```

```java
class Solution {
    private int res;
    public int longestConsecutive(TreeNode root) {
        res = 0;

        dfs(root);

        return res;
    }

    private int dfs(TreeNode root) {
        if (root == null) {
            return 0;
        }

        int left  = dfs(root.left);
        int right = dfs(root.right);

        int curr = 1;
        if (root.left != null && root.val + 1 == root.left.val) {
            curr = Math.max(curr, left + 1);
        }
        if (root.right != null && root.val + 1 == root.right.val) {
            curr = Math.max(curr, right + 1);
        }

        res = Math.max(res, curr);

        return curr;
    }
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://luj.gitbook.io/code/tree/4-path/binary-tree-longest-consecutive-sequence.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.