[Function add]

1. Add leetcode solutions with tag tree.

Author: Seanforfun

README.md

@@ -682,8 +682,20 @@
 * [112. Path Sum](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/112.%20Path%20Sum.md)
 * [113. Path Sum II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/113.%20Path%20Sum%20II.md)
 * [437. Path Sum III](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/437.%20Path%20Sum%20III.md)
-
-
+#### Use both nodes, return one.
+* [124. Binary Tree Maximum Path Sum](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/124.%20Binary%20Tree%20Maximum%20Path%20Sum.md)
+* [543. Diameter of Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/543.%20Diameter%20of%20Binary%20Tree.md)
+* [687. Longest Univalue Path](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/687.%20Longest%20Univalue%20Path.md)
+* [129. Sum Root to Leaf Numbers](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/129.%20Sum%20Root%20to%20Leaf%20Numbers.md)
+* [257. Binary Tree Paths](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/257.%20Binary%20Tree%20Paths.md)
+* [235. Lowest Common Ancestor of a Binary Search Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/235.%20Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.md)
+* [236. Lowest Common Ancestor of a Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/236.%20Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.md)
+* [297. Serialize and Deserialize Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/297.%20Serialize%20and%20Deserialize%20Binary%20Tree.md)
+* [449. Serialize and Deserialize BST](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/449.%20Serialize%20and%20Deserialize%20BST.md)
+* [508. Most Frequent Subtree Sum](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/508.%20Most%20Frequent%20Subtree%20Sum.md)
+* [968. Binary Tree Cameras](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/968.%20Binary%20Tree%20Cameras.md)
+* [337. House Robber III](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/337.%20House%20Robber%20III.md)
+* [979. Distribute Coins in Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/979.%20Distribute%20Coins%20in%20Binary%20Tree.md)
 
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.

leetcode/236. Lowest Common Ancestor of a Binary Tree.md

@@ -181,3 +181,28 @@ class Solution {
     }
 }
 ```
+
+### Third Time
+* Method 1: Divide and Conquer
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+			if(root == p || root == q || root == null) return root;
+			TreeNode left = lowestCommonAncestor(root.left, p, q);
+			TreeNode right = lowestCommonAncestor(root.right, p, q);
+			if(left != null && right != null) return root;
+			else if(left != null) return left;
+			else if(right != null) return right;
+			return null;
+		}
+	}
+	```

leetcode/337. House Robber III.md

@@ -79,29 +79,59 @@ class Solution {
 	* 如何求出到当前节点的最大值。
 	* 我们需要两个条件，到子结点的最大值，孙结点的最大值 + 当前值。
 
-```Java
-/**
- * Definition for a binary tree node.
- * public class TreeNode {
- *     int val;
- *     TreeNode left;
- *     TreeNode right;
- *     TreeNode(int x) { val = x; }
- * }
- */
-class Solution {
-    public int rob(TreeNode root) {
-        return dfs(root)[0];
-    }
-    private int[] dfs(TreeNode root){
-        int[] max = {0, 0}; //max[0]: 到当前节点的最大值； max[1]: 到子结点的最大值
-        if(root != null){
-            int[] maxLeft = dfs(root.left);
-            int[] maxRight = dfs(root.right);
-            max[1] = maxLeft[0] + maxRight[0];	//子结点的最大值
-            max[0] = Math.max(maxLeft[1] + maxRight[1] + root.val, max[1]);	//当前的最大值为max(孙结点的最大值 + 当前值, 子结点最大值)。
-        }
-        return max;
-    }
-}
-```
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		public int rob(TreeNode root) {
+			return dfs(root)[0];
+		}
+		private int[] dfs(TreeNode root){
+			int[] max = {0, 0}; //max[0]: 到当前节点的最大值； max[1]: 到子结点的最大值
+			if(root != null){
+				int[] maxLeft = dfs(root.left);
+				int[] maxRight = dfs(root.right);
+				max[1] = maxLeft[0] + maxRight[0];	//子结点的最大值
+				max[0] = Math.max(maxLeft[1] + maxRight[1] + root.val, max[1]);	//当前的最大值为max(孙结点的最大值 + 当前值, 子结点最大值)。
+			}
+			return max;
+		}
+	}
+	```
+
+### Second Time
+* Method 1: DFS + DP
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		public int rob(TreeNode root) {
+			return dfs(root)[0];
+		}
+		private int[] dfs(TreeNode node){
+			if(node == null) return new int[]{0, 0};
+			else{
+				int[] left = dfs(node.left);
+				int[] right = dfs(node.right);
+				int[] result = new int[2];
+				result[1] = left[0] + right[0];
+				result[0] = Math.max(result[1], node.val + left[1] + right[1]);
+				return result;
+			}
+		}
+	}
+	```

leetcode/968. Binary Tree Cameras.md

@@ -0,0 +1,61 @@
+## 968. Binary Tree Cameras
+
+### Question:
+Given a binary tree, we install cameras on the nodes of the tree. 
+Each camera at a node can monitor its parent, itself, and its immediate children.
+Calculate the minimum number of cameras needed to monitor all nodes of the tree.
+
+```
+Example 1:
+
+Input: [0,0,null,0,0]
+Output: 1
+Explanation: One camera is enough to monitor all nodes if placed as shown.
+
+Example 2:
+
+Input: [0,0,null,0,null,0,null,null,0]
+Output: 2
+Explanation: At least two cameras are needed to monitor all nodes of the tree. The above image shows one of the valid configurations of camera placement.
+```
+
+Note:
+1. The number of nodes in the given tree will be in the range [1, 1000].
+2. Every node has value 0.
+
+### Solution:
+* Method 1: dfs + Greedy
+    * I didn't get this question by myself.
+    ```Java
+    /**
+     * Definition for a binary tree node.
+     * public class TreeNode {
+     *     int val;
+     *     TreeNode left;
+     *     TreeNode right;
+     *     TreeNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        private static final int NULL = 0;
+        private static final int COVER = 1;
+        private static final int CAMERA = 2;
+        private int res;
+        public int minCameraCover(TreeNode root) {
+            if(dfs(root) == NULL) res++;
+            return res;
+        }
+        private int dfs(TreeNode node){
+            if(node == null) return COVER;
+            int left = dfs(node.left);
+            int right = dfs(node.right);
+            if(left == NULL || right == NULL){
+                res++;
+                return CAMERA;
+            }
+            if(left == CAMERA || right == CAMERA) return COVER;
+            return NULL;
+        }
+    }
+    ```
+   

leetcode/979. Distribute Coins in Binary Tree.md

@@ -0,0 +1,72 @@
+## 979. Distribute Coins in Binary Tree
+
+### Question:
+Given the root of a binary tree with N nodes, each node in the tree has node.val coins, and there are N coins total.
+
+In one move, we may choose two adjacent nodes and move one coin from one node to another.  (The move may be from parent to child, or from child to parent.)
+
+Return the number of moves required to make every node have exactly one coin.
+
+```
+Example 1:
+
+Input: [3,0,0]
+Output: 2
+Explanation: From the root of the tree, we move one coin to its left child, and one coin to its right child.
+
+Example 2:
+
+Input: [0,3,0]
+Output: 3
+Explanation: From the left child of the root, we move two coins to the root [taking two moves].  Then, we move one coin from the root of the tree to the right child.
+
+Example 3:
+
+Input: [1,0,2]
+Output: 2
+
+Example 4:
+
+Input: [1,0,0,null,3]
+Output: 4
+```
+ 
+Note:
+1. 1<= N <= 100
+2. 0 <= node.val <= N
+
+
+
+### Solution:
+* Method 1: Recursion
+    ```Java
+    /**
+     * Definition for a binary tree node.
+     * public class TreeNode {
+     *     int val;
+     *     TreeNode left;
+     *     TreeNode right;
+     *     TreeNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        private int res;
+        public int distributeCoins(TreeNode root) {
+            balance(root);
+            return res;
+        }
+        private int balance(TreeNode node){
+            if(node == null) return 0;
+            else{
+                int left = balance(node.left);
+                int right = balance(node.right);
+                res += Math.abs(left) + Math.abs(right);
+                return node.val - 1 + left + right;
+            }
+        }
+    }
+    ```
+
+### Reference
+1. [花花酱 LeetCode 979. Distribute Coins in Binary Tree](https://zxi.mytechroad.com/blog/tree/leetcode-979-distribute-coins-in-binary-tree/)
+