solve problem Longest Univalue Path

Author: P-ppc

README.md

@@ -177,6 +177,7 @@ All solutions will be accepted!
 |836|[Rectangle Overlap](https://leetcode-cn.com/problems/rectangle-overlap/description/)|[java/py/js](./algorithms/RectangleOverlap)|Easy|
 |643|[Maximum Average Subarray I](https://leetcode-cn.com/problems/maximum-average-subarray-i/description/)|[java/py/js](./algorithms/MaximumAverageSubarrayI)|Easy|
 |189|[Rotate Array](https://leetcode-cn.com/problems/rotate-array/description/)|[java/py/js](./algorithms/RotateArray)|Easy|
+|687|[Longest Univalue Path](https://leetcode-cn.com/problems/longest-univalue-path/description/)|[java/py/js](./algorithms/LongestUnivaluePath)|Easy|
 
 # Database
 |#|Title|Solution|Difficulty|

algorithms/LongestUnivaluePath/README.md

@@ -0,0 +1,2 @@
+# Longest Univalue Path
+This problem is easy to solve by postorder traversal

algorithms/LongestUnivaluePath/Solution.java

@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public int longestUnivaluePath(TreeNode root) {
+        int longestPath = 0;
+        Map<TreeNode, Integer> pathMap = new HashMap<TreeNode, Integer>();
+        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
+        
+        if (root != null) stack.addLast(root);
+        
+        while (stack.size() > 0) {
+            TreeNode node = stack.getLast();
+            
+            if (node.left != null && pathMap.get(node.left) == null) {
+                stack.addLast(node.left);
+            } else if (node.right != null && pathMap.get(node.right) == null) {
+                stack.addLast(node.right);
+            } else {
+                stack.removeLast();
+                int path = 0;
+
+                if (node.left != null || node.right != null) {
+                    int leftPath = node.left != null && node.left.val == node.val ? 1 + pathMap.get(node.left) : 0,
+                        rightPath = node.right != null && node.right.val == node.val ? 1 + pathMap.get(node.right) : 0;
+                    pathMap.put(node, Math.max(leftPath, rightPath));
+                    path = leftPath + rightPath;
+                } else {
+                    pathMap.put(node, 0);
+                }
+
+                longestPath = Math.max(longestPath, path);
+            }
+        }
+        
+        return longestPath;
+    }
+}

algorithms/LongestUnivaluePath/solution.js

@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var longestUnivaluePath = function(root) {
+    let longestPath = 0,
+        pathMap = new Map(),
+        stack = []
+    
+    if (root) stack.push(root)
+    
+    while (stack.length > 0) {
+        let node = stack[stack.length - 1]
+        if (node.left && pathMap.get(node.left) === undefined) {
+            stack.push(node.left)
+        } else if (node.right && pathMap.get(node.right) === undefined) {
+            stack.push(node.right)
+        } else {
+            stack.pop()
+            let path = 0
+            
+            if (node.left || node.right) {
+                let leftPath = node.left && node.left.val === node.val ? 1 + pathMap.get(node.left) : 0,
+                    rightPath = node.right && node.right.val === node.val ? 1 + pathMap.get(node.right) : 0
+                pathMap.set(node, Math.max(leftPath, rightPath))
+                path = leftPath + rightPath
+            } else {
+                pathMap.set(node, 0)
+            }
+            
+            longestPath = Math.max(longestPath, path)
+        }
+    }
+        
+    
+    return longestPath
+};

algorithms/LongestUnivaluePath/solution.py

@@ -0,0 +1,40 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def longestUnivaluePath(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        longest_path = 0
+        path_map = {}
+        stack = []
+        
+        if root: stack.append(root)
+        
+        while len(stack) > 0:
+            node = stack[-1]
+            if node.left and path_map.get(node.left) == None:
+                stack.append(node.left)
+            elif node.right and path_map.get(node.right) == None:
+                stack.append(node.right)
+            else:
+                stack.pop()
+                path = 0
+                
+                if node.left != None or node.right != None:
+                    left_path = 1 + path_map.get(node.left) if node.left != None and node.left.val == node.val else 0
+                    right_path = 1 + path_map.get(node.right) if node.right != None and node.right.val == node.val else 0
+                    path_map[node] = max(left_path, right_path)
+                    path = left_path + right_path
+                else:
+                    path_map[node] = 0
+                    
+                longest_path = max(longest_path, path)
+        
+        return longest_path