[Function add]

1. Add leetcode solutions.

Author: Seanforfun

README.md

@@ -361,6 +361,12 @@
 
 [207. Course Schedule](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/207.%20Course%20Schedule.md)
 
+[208. Implement Trie (Prefix Tree)](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/208.%20Implement%20Trie%20(Prefix%20Tree).md)
+
+[209. Minimum Size Subarray Sum](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/209.%20Minimum%20Size%20Subarray%20Sum.md)
+
+[210. Course Schedule II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/210.%20Course%20Schedule%20II.md)
+
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.
 All java realization codes are placed in different packages.

leetcode/208. Implement Trie (Prefix Tree).md

@@ -79,4 +79,76 @@ class Trie {
  * boolean param_2 = obj.search(word);
  * boolean param_3 = obj.startsWith(prefix);
  */
-```
+```
+
+### 二刷
+1. 最典型的字典树，将每个字符作为一个结点，我们通过遍历的方式，将一个字符串的所有字符添加进入当前的树中。
+2. 如果已经到了最后一个字符，我们将当前节点的isLeaf设置成true。
+
+```Java
+class Trie {
+    private static class TrieNode{
+        boolean isLeaf;
+        TrieNode[] childs;
+        public TrieNode(){
+            childs = new TrieNode[26];
+        }
+    }
+    private TrieNode root;
+    /** Initialize your data structure here. */
+    public Trie() {
+        this.root = new TrieNode();
+    }
+    
+    /** Inserts a word into the trie. */
+    public void insert(String word) {
+        int len = word.length();
+        TrieNode temp = root;
+        for(int i = 0; i < len; i++){
+            int c = word.charAt(i) - 'a';
+            if(temp.childs[c] == null){
+                temp.childs[c] = new TrieNode();
+            }
+            temp = temp.childs[c];
+        }
+        temp.isLeaf = true;
+    }
+    
+    /** Returns if the word is in the trie. */
+    public boolean search(String word) {
+        if(word == null || word.length() == 0) return true;
+        int len = word.length();
+        TrieNode temp = this.root;
+        for(int i = 0; i < len; i++){
+            int c = word.charAt(i) - 'a';
+            if(temp.childs[c] == null) return false;
+            else temp = temp.childs[c];
+        }
+        return temp.isLeaf;
+    }
+    
+    /** Returns if there is any word in the trie that starts with the given prefix. */
+    public boolean startsWith(String prefix) {
+        if(prefix == null || prefix.length() == 0) return false;
+        int len = prefix.length();
+        TrieNode temp = root;
+        for(int i = 0; i < len; i++){
+            int c = prefix.charAt(i) - 'a';
+            if(temp.childs[c] == null) return false;
+            temp = temp.childs[c];
+        }
+        return true;
+    }
+}
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * Trie obj = new Trie();
+ * obj.insert(word);
+ * boolean param_2 = obj.search(word);
+ * boolean param_3 = obj.startsWith(prefix);
+ */
+```
+
+### Reference
+1. [Trie Tree 字典树](https://seanforfun.github.io/datastructure/2018/11/07/TrieTree.html)

leetcode/209. Minimum Size Subarray Sum.md

@@ -63,4 +63,34 @@ class Solution {
         return min == Integer.MAX_VALUE ? 0: min;
     }
 }
+```
+
+### 二刷
+1. 还是使用了双指针解决了这个问题。
+2. 如果sum >= s, 右移左指针。
+3. 如果sum < s, 右移右指针。
+```Java
+class Solution {
+    public int minSubArrayLen(int s, int[] nums) {
+        int len = nums.length;
+        int left = -1, right = -1;
+        int result = nums.length;
+        int sum = 0;
+        boolean flag = false;
+        while(left < len){
+            if(sum < s && right < len){
+                if(++right >= len) break;
+                sum += nums[right];
+            }
+            if(sum >= s){
+                flag = true;
+                result = Math.min(result, right - left);
+                if(left < right){
+                    sum -= nums[++left];
+                }else return 1;
+            }
+        }
+        return flag ? result : 0;
+    }
+}
 ```

leetcode/210. Course Schedule II.md

@@ -68,4 +68,87 @@ class Solution {
         return result;
     }
 }
+```
+
+### 二刷
+1. Method 1: Khan 排序
+```Java
+class Solution {
+    public int[] findOrder(int numCourses, int[][] prerequisites) {
+        int[] indegree = new int[numCourses];
+        Map<Integer, List<Integer>> pre = new HashMap<>();
+        for(int[] p : prerequisites){
+            indegree[p[0]]++;
+            List<Integer> temp = pre.containsKey(p[1]) ? pre.get(p[1]) : new ArrayList<>();
+            temp.add(p[0]);
+            pre.put(p[1], temp);
+        }
+        int[] order = new int[numCourses];
+        int count = 0;
+        LinkedList<Integer> queue = new LinkedList<>();
+        for(int i = 0; i < numCourses; i++){
+            if(indegree[i] == 0){
+                queue.add(i);
+            }
+        }
+        while(!queue.isEmpty()){
+            int cur = queue.poll();
+            order[count++] = cur;
+            if(pre.containsKey(cur)){
+                List<Integer> temp = pre.get(cur);
+                for(Integer t : temp){
+                    indegree[t]--;
+                    if(indegree[t] == 0) queue.add(t);
+                }
+            }
+        }
+        for(int i = 0; i < numCourses; i++){
+            if(indegree[i] != 0){
+                return new int[0];
+            }
+        }
+        return order;
+    }
+}
+```
+
+2. Method 2: dfs
+```Java
+class Solution {
+    List<Integer> order = new LinkedList<>();
+    public int[] findOrder(int numCourses, int[][] prerequisites) {
+        int[] indegree = new int[numCourses];
+        Map<Integer, List<Integer>> pre = new HashMap<>();
+        for(int[] p : prerequisites){
+            indegree[p[0]]++;
+            List<Integer> temp = pre.containsKey(p[1]) ? pre.get(p[1]) : new ArrayList<>();
+            temp.add(p[0]);
+            pre.put(p[1], temp);
+        }
+        boolean[] visited = new boolean[numCourses];
+        for(int i = 0; i < numCourses; i++){
+            if(!visited[i] && indegree[i] == 0)
+                dfs(i, pre, indegree, visited);
+        }
+        for(boolean b : visited)
+            if(!b) return new int[0];
+        int[] orders = new int[numCourses];
+        for(int i = 0; i < this.order.size(); i++){
+            orders[i] = this.order.get(i);
+        }
+        return orders;
+    }    
+    private void dfs(int cur, Map<Integer, List<Integer>> pre, int[] indegree, boolean[] visited){
+        visited[cur] = true;
+        this.order.add(cur);
+        if(pre.containsKey(cur)){
+            List<Integer> temp = pre.get(cur);
+            for(Integer t :temp){
+                if((--indegree[t]) == 0 && !visited[t]){
+                    dfs(t, pre, indegree, visited);
+                }
+            }
+        }
+    }
+}
 ```