feat: add the solution of Longest Univalue Path(687) with Java.

Author: Mukyu

README.md

@@ -74,7 +74,7 @@
 | [680][680-question] | [Valid Palindrome II][680-tips]                              | [✅][680-java] | [✅][680-js] |                  |
 | [682][682-question] | [Baseball Game][682-tips]                                    | [✅][682-java] | [✅][682-js] |                  |
 | [686][686-question] | [Repeated String Match][686-tips]                            | [✅][686-java] | [✅][686-js] |                  |
-| [687][687-question] | [Longest Univalue Path][687-tips]                            |                | [✅][687-js] |                  |
+| [687][687-question] | [Longest Univalue Path][687-tips]                            | [✅][687-java] | [✅][687-js] |                  |
 | [693][693-question] | [Binary Number with Alternating Bits][693-tips]              |                | [✅][693-js] |                  |
 | [695][695-question] | [Max Area of Island][695-tips]                               |                | [✅][695-js] |                  |
 | [696][696-question] | [Count Binary Substrings][696-tips]                          |                | [✅][696-js] |                  |
@@ -471,6 +471,7 @@
 [674-java]: ./src/_674/Solution.java
 [680-java]: ./src/_680/Solution.java
 [686-java]: ./src/_686/Solution.java
+[687-java]: ./src/_687/Solution.java
 [682-java]: ./src/_682/Solution.java
 [728-java]: ./src/_728/Solution.java
 [771-java]: ./src/_771/Solution.java

src/_687/Solution.java

@@ -0,0 +1,38 @@
+package _687;
+
+class Solution {
+    private int maxLen = 0;
+
+    public int longestUnivaluePath(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        dfs(root, root.val + 1);
+        return maxLen;
+    }
+
+    private int dfs(TreeNode node, int rootVal) {
+        if (node == null) return 0;
+
+        int left = dfs(node.left, node.val);
+        int right = dfs(node.right, node.val);
+
+        if (node.val == rootVal) {
+            return Math.max(left, right) + 1;
+        }
+
+        maxLen = Math.max(maxLen, left + right);
+
+        return 0;
+    }
+
+    private class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+}

tips/687/README.md

@@ -1,46 +1,128 @@
-[xxxx][title]
+[Longest Univalue Path][title]
 
 ## Description
-// 抄题目
 
+Given a binary tree, find the length of the longest path where each node in the path has the same value. This path may or may not pass through the root.
 
-**Example:**
+**Note:** The length of path between two nodes is represented by the number of edges between them.
+
+**Example 1:**
+
+Input:
 
 ```
-// 抄Example
+              5
+             / \
+            4   5
+           / \   \
+          1   1   5
 ```
 
-**Note:**
-// Note
+Output:
 
-**Tags:** // tags
+```
+2
+```
 
+**Example 2:**
 
-## 思路 1
-// 贴一些关键代码,说一些解题思路
-// (同一种语言可以写多种思路，与某种语言思路相同的另一种语言的思路无须赘述，但可以把代码贴在后面) 
-```java
+Input:
 
 ```
-```javascript
+              1
+             / \
+            4   5
+           / \   \
+          4   4   5
+```
+
+Output:
 
+```
+2
 ```
 
-## 思路 2
-// 贴一些关键代码,说一些解题思路
-```java
+**Note:** The given binary tree has not more than 10000 nodes. The height of the tree is not more than 1000.
 
+**Tags:** [Tree](https://leetcode.com/tag/tree/)、[Recursion](https://leetcode.com/tag/recursion/)
+
+
+## 思路
+
+计算二叉树中最长的连续相同节点所形成的的路径的长度（节点之间边的数量代表长度）。根据二叉树的特性，用深度优先搜索，对连续相同的节点进行计数即可，需要遵循以下原则：
+
+- 当遇到两条相同的路径可以连接至同一个父节点时，选择较长的路径即可。例如：
+
+```
+      1
+     / \
+   [1]  2
+   / \
+  1   1
+ /
+1
 ```
 
-## 思路 3
-// 贴一些关键代码,说一些解题思路
-```kotlin
+在所框选的节点上有两条路径连接着。即：
 
+```
+      1            1
+     /            /
+   [1]          [1]
+   /      或      \
+  1                1
+ /
+1
+```
+
+当然，是选择左边的这条较长的路径。
+
+- 当遇到两条相同的路径可以连接至同一个父节点，且此父节点不能继续向上连接时，可以将两个子节点路径连接起来。例如：
+
+```
+   [1]
+   / \
+  1   1
+ /
+1
+```
+
+此时的路径长度等于左边的两条加上右边的一条，总长度为三。
+
+**Java:**
+
+```java
+class Solution {
+    private int maxLen = 0;
+
+    public int longestUnivaluePath(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        dfs(root, root.val + 1);
+        return maxLen;
+    }
+
+    private int dfs(TreeNode node, int rootVal) {
+        if (node == null) return 0;
+
+        int left = dfs(node.left, node.val);
+        int right = dfs(node.right, node.val);
+
+        if (node.val == rootVal) {
+            return Math.max(left, right) + 1;
+        }
+
+        maxLen = Math.max(maxLen, left + right);
+
+        return 0;
+    }
+}
 ```
 
 ## 结语
-   
+
 如果你同我们一样热爱数据结构、算法、LeetCode，可以关注我们 GitHub 上的 LeetCode 题解：[LeetCode-Solution][ls]
 
-[title]: https://leetcode.com/problems/xxxx
+[title]: https://leetcode.com/problems/longest-univalue-path/description/
 [ls]: https://github.com/RichCodersAndMe/LeetCode-Solution