BinaryTreeLongestConsecutiveSequence298

Author: fluency03

README.md

@@ -44,11 +44,11 @@
 | [Graph](https://github.com/fluency03/leetcode-java/blob/master/src/graph) |
 
 
-# Total: 379
+# Total: 380
 
 |   Easy  |  Medium | Hard | - |
 |:-------:|:-------:|:----:|:-:|
-|   102   |   207   |  66  | 4 |
+|   102   |   208   |  66  | 4 |
 
 
 | Question | Solution | Difficulty |
@@ -259,6 +259,7 @@
 | [289. Game of Life](https://leetcode.com/problems/game-of-life/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/GameOfLife289.java) | Medium |
 | [295. Find Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/FindMedianFromDataStream295.java) | Hard |
 | [297. Serialize and Deserialize Binary Tree](https://leetcode.com/problems/serialize-and-deserialize-binary-tree/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/SerializeAndDeserializeBinaryTree297.java) | Hard |
+| [298. Binary Tree Longest Consecutive Sequence](https://leetcode.com/problems/binary-tree-longest-consecutive-sequence/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/BinaryTreeLongestConsecutiveSequence298.java) | Medium |
 | [299. Bulls and Cows](https://leetcode.com/problems/bulls-and-cows/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/BullsAndCows299.java) | Medium |
 | [300. Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/LongestIncreasingSubsequence300.java) | Medium |
 | [301. Remove Invalid Parentheses](https://leetcode.com/problems/remove-invalid-parentheses/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/RemoveInvalidParentheses301.java) | Hard |

src/BinaryTreeLongestConsecutiveSequence298.java

@@ -0,0 +1,105 @@
+/**
+ * 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 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.
+ */
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+
+public class BinaryTreeLongestConsecutiveSequence298 {
+    public int longestConsecutive(TreeNode root) {
+        if (root == null) return 0;
+        return helper(root, 0);
+    }
+
+    public int helper(TreeNode root, int i) {
+        if (root == null) return i;
+        
+        int l = i + 1;
+        if (root.left != null) {
+            if (root.val + 1 == root.left.val) {
+                l = helper(root.left, i+1);
+            } else {
+                l = helper(root.left, 0);
+            }
+        }
+
+        int r = i + 1;
+        if (root.right != null) {
+            if (root.val + 1 == root.right.val) {
+                r = helper(root.right, i+1);
+            } else {
+                r = helper(root.right, 0);
+            }
+        }
+
+        return Math.max(Math.max(l, r), i+1);
+    }
+
+
+    /**
+     * Bottom-up
+     * https://leetcode.com/problems/binary-tree-longest-consecutive-sequence/solution/
+     */
+    private int maxLength = 0;
+    public int longestConsecutive2(TreeNode root) {
+        dfs(root);
+        return maxLength;
+    }
+    
+    private int dfs(TreeNode p) {
+        if (p == null) return 0;
+        int L = dfs(p.left) + 1;
+        int R = dfs(p.right) + 1;
+        if (p.left != null && p.val + 1 != p.left.val) {
+            L = 1;
+        }
+        if (p.right != null && p.val + 1 != p.right.val) {
+            R = 1;
+        }
+        int length = Math.max(L, R);
+        maxLength = Math.max(maxLength, length);
+        return length;
+    }
+
+}