[Function add]

1. Add leetcode solutions.

Author: Seanforfun

README.md

@@ -463,6 +463,12 @@
 
 [295.Find Median from Data Stream](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/295.Find%20Median%20from%20Data%20Stream.md)
 
+[297. Serialize and Deserialize Binary Tree](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/297.%20Serialize%20and%20Deserialize%20Binary%20Tree.md)
+
+[299. Bulls and Cows](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/299.%20Bulls%20and%20Cows.md)
+
+[300. Longest Increasing Subsequence](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/300.%20Longest%20Increasing%20Subsequence.md)
+
 
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.

leetcode/297. Serialize and Deserialize Binary Tree.md

@@ -73,6 +73,61 @@ public class Codec {
     }
 }
 
+// Your Codec object will be instantiated and called as such:
+// Codec codec = new Codec();
+// codec.deserialize(codec.serialize(root));
+```
+
+### Second time
+![Imgur](https://i.imgur.com/IcQCB2w.png)
+```Java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Codec {
+    private final String split = ",";
+    private final String empty = "#";
+    
+    // Encodes a tree to a single string.
+    public String serialize(TreeNode root) {
+        StringBuilder sb = new StringBuilder();
+        serialize(root, sb);
+        return sb.toString();
+    }
+    private void serialize(TreeNode node, StringBuilder sb){
+        if(node == null){
+            sb.append(empty).append(split);
+        }else{
+            sb.append(node.val).append(split);
+            serialize(node.left, sb);
+            serialize(node.right, sb);
+        }
+    }
+    // Decodes your encoded data to tree.
+    public TreeNode deserialize(String data) {
+        String[] nodes = data.split(split);
+        LinkedList<String> q = new LinkedList<>();
+        q.addAll(Arrays.asList(nodes));
+        return deserialize(q);
+    }
+    private TreeNode deserialize(LinkedList<String> q){
+        String val = q.poll();
+        if(val.equals(empty)){
+            return null;
+        }else{
+            TreeNode node = new TreeNode(Integer.parseInt(val));
+            node.left = deserialize(q);
+            node.right = deserialize(q);
+            return node;
+        }
+    }
+}
 // Your Codec object will be instantiated and called as such:
 // Codec codec = new Codec();
 // codec.deserialize(codec.serialize(root));

leetcode/299. Bulls and Cows.md

@@ -64,4 +64,34 @@ class Solution {
         return sb.toString();
     }
 }
+```
+
+### Second time
+1. We actually need 2 arrays to save the frequency of the each letters.
+2. If save position and value, nothing saved to table, and A++.
+3. If not save, increase the frequency for both of the values.
+4. Finally we take the sum of the minimum values in bonth arrays, which is the value of B.
+```Java
+class Solution {
+    public String getHint(String secret, String guess) {
+        char[] sArr = secret.toCharArray();
+        char[] gArr = guess.toCharArray();
+        int A = 0;
+        int B = 0;
+        int[] aCount = new int[10];
+        int[] bCount = new int[10];
+        for(int i = 0; i < sArr.length; i++){
+            if(sArr[i] == gArr[i]){
+                A++;
+            }else{
+                aCount[sArr[i] - '0']++;
+                bCount[gArr[i] - '0']++;
+            }
+        }
+        for(int i = 0; i < 10; i++){
+            B += Math.min(aCount[i], bCount[i]);
+        }
+        return A + "A" + B + "B";
+    }
+}
 ```

leetcode/300. Longest Increasing Subsequence.md

@@ -35,4 +35,28 @@ class Solution {
         return res;
     }
 }
+```
+
+### Second time
+1. Still use dp to solve this question. O(N^2)
+```Java
+class Solution {
+    public int lengthOfLIS(int[] nums) {
+        if(nums == null || nums.length == 0) return 0;
+        int len = nums.length;
+        int[] dp = new int[len + 1];
+        for(int i = 1; i <= len; i++) dp[i] = 1;
+        int result = 1;
+        for(int i = 2; i <= len; i++){
+            int num = nums[i - 1];
+            for(int j = i - 1; j >= 1; j--){
+                if(num > nums[j - 1]){
+                    dp[i] = Math.max(dp[i], dp[j] + 1);
+                }
+            }
+            result = Math.max(dp[i], result);
+        }
+        return result;
+    }
+}
 ```