3.17.f

awangdev · awangdev · commit 50e83db3e4bf · 2016-03-18T02:06:03.000-04:00
diff --git a/Java/Best Time to Buy and Sell Stock IV.java b/Java/Best Time to Buy and Sell Stock IV.java
@@ -10,6 +10,9 @@
    local[i][j] = max(global[i – 1][j – 1] + diff, local[i – 1][j] + diff)    
    global[i][j] = max(global[i – 1][j], local[i][j])     
 
+local[i][j]: 第i天，当天一定进行第j次交易的profit     
+global[i][j]: 第i天，总共进行了j次交易的profit.
+
 local[i][j]和global[i][j]的区别是：local[i][j]意味着在第i天一定有交易（卖出）发生。    
    当第i天的价格高于第i-1天（即diff > 0）时，那么可以把这次交易（第i-1天买入第i天卖出）跟第i-1天的交易（卖出）合并为一次交易，即local[i][j]=local[i-1][j]+diff；    
    当第i天的价格不高于第i-1天（即diff<=0）时，那么local[i][j]=global[i-1][j-1]+diff，而由于diff<=0，所以可写成local[i][j]=global[i-1][j-1]。    
diff --git a/Java/Clone Graph.java b/Java/Clone Graph.java
@@ -1,3 +1,11 @@
+M
+
+Use HashMap to mark cloned nodes.    
+
+先能复制多少Node复制多少。然后把neighbor 加上
+
+
+```
 /*
 Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.
 
@@ -23,7 +31,7 @@
          \_/
 Hide Tags Depth-first Search Breadth-first Search Graph
 
-	
+    
 */
 
 /*
@@ -134,3 +142,5 @@ public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
     }
 }
 
+
+```
diff --git a/Java/Copy List with Random Pointer.java b/Java/Copy List with Random Pointer.java
@@ -9,7 +9,8 @@
 ```
 /*
 
-A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.
+A linked list is given such that each node contains an additional random pointer 
+which could point to any node in the list or null.
 
 Return a deep copy of the list.
 
diff --git a/Java/Count Primes.java b/Java/Count Primes.java
@@ -1,12 +1,16 @@
-什么是prime number: >=2的没有除自己和1以外公约数的数。
-还有另外一个中定义方法：
-这个n,有没有小于n的一个i,而达到： i*i + # of i = n. 如果有，那就不是 prime。 
+E
+
+什么是prime number: >=2的没有除自己和1以外公约数的数。   
+
+还有另外一个定义方法!!    
+这个n,有没有小于n的一个i,而达到： i*i + # of i = n. 如果有，那就不是 prime。     
+
+方法很牛逼也很数学。没做的时候可能想不到。做了之后就觉得，哎，我去，有道理啊。   
+简而言之：简历一个boolean长条，存isPrime[]。 然后从i=2， 全部变true.    
+然后利用这个因子的性质，非prime满足条件： self*self, self * self + self ... etc.     
+所以就check每一个j, j+i, j+i+i, 然后把所有non-prime全部mark成false.     
+最后，数一遍还剩下的true个数就好了   
 
-方法很牛逼也很数学。没做的时候可能想不到。做了之后就觉得，哎，我去，有道理啊。
-简而言之：简历一个boolean长条，存isPrime[]。 然后从i=2， 全部变true.
-然后利用这个因子的性质，非prime满足条件： self*self, self * self + self ... etc.
-所以就check每一个j, j+i, j+i+i, 然后把所有non-prime全部mark成false.
-最后，数一遍还剩下的true个数就好了
 ```
 /*
 Description:
@@ -19,7 +23,8 @@
 Attempt2: https://leetcode.com/problems/count-primes/ explains it well
 1. Ignore 1 and n. Don't count 1 and the number itself in.
 2. Assume all numbers are prime in a boolean[]. Check off those are certainly not prime, the remaining will be prime.
-3. For any n, only need to check up to i * i < n; more than that, for example 2 x 6 is same as checking 6x2, but 6x2 is not necessary to check.
+3. For any n, only need to check up to i * i < n; more than that, 
+for example 2 x 6 is same as checking 6x2, but 6x2 is not necessary to check.
 4. How to mark things off:
 	The first non-prime is always i^2: self * self.
 	Then more non-primes:self * self, self * (self + 1), self * (self + 2) ... etc.
diff --git a/Java/Find the Connected Component in the Undirected Graph.java b/Java/Find the Connected Component in the Undirected Graph.java
@@ -1,12 +1,15 @@
-BFS遍历，把每个node的neighbor都加进来。
+M
+ 
+BFS遍历，把每个node的neighbor都加进来。    
 
-一定注意要把visit过的node Mark一下。因为curr node也会是别人的neighbor，会无限循环。
+一定注意要把visit过的node Mark一下。因为curr node也会是别人的neighbor，会无限循环。      
 
-Component的定义：所有Component内的node必须被串联起来via path (反正这里是undirected, 只要链接上就好)
+Component的定义：所有Component内的node必须被串联起来via path (反正这里是undirected, 只要链接上就好)     
 
-这道题：其实component在input里面都已经给好了，所有能一口气visit到的，全部加进queue里面，他们就是一个component里面的了。
+这道题：其实component在input里面都已经给好了，所有能一口气visit到的，全部加进queue里面，他们就是一个component里面的了。     
+
+而我们这里不需要判断他们是不是Component。   
 
-而我们这里不需要判断他们是不是Component。
 ```
  /*
 Find the number connected component in the undirected graph. 
diff --git a/Java/Find the Weak Connected Component in the Directed Graph.java b/Java/Find the Weak Connected Component in the Directed Graph.java
@@ -1,16 +1,19 @@
-Identify这是个union-find问题还挺巧妙。
-看到了weak component的形式： 一个点指向所有，那么所有的点都有一个公共的parent，然后就是要找出这些点。
+M
 
-为何不能从一个点出发，比如A，直接print它所有的neighbors呢？
-	不行，如果轮到了B点，那因为是directed,它也不知道A的情况，也不知道改如何继续加，或者下手。
+Identify这是个union-find问题还挺巧妙。    
+看到了weak component的形式： 一个点指向所有，那么所有的点都有一个公共的parent，然后就是要找出这些点。    
 
-所以，要把所有跟A有关系的点，或者接下去和A的neighbor有关系的点，都放进union-find里面，让这些点有Common parents.
+为何不能从一个点出发，比如A，直接print它所有的neighbors呢？     
+	不行，如果轮到了B点，那因为是directed,它也不知道A的情况，也不知道改如何继续加，或者下手。    
+
+所以，要把所有跟A有关系的点，或者接下去和A的neighbor有关系的点，都放进union-find里面，让这些点有Common parents.     
+
+最后output的想法：    
+做一个 map <parent ID, list>。    
+之前我们不是给每个num都存好了parent了嘛。    
+每个num都有个parent, 然后不同的parent就创造一个不同的list。   
+最后，把Map里面所有的list拿出来就好了。    
 
-最后output的想法：
-做一个 map <parent ID, list>。
-之前我们不是给每个num都存好了parent了嘛。
-每个num都有个parent, 然后不同的parent就创造一个不同的list。
-最后，把Map里面所有的list拿出来就好了。
 ```
 /*
 Find the number Weak Connected Component in the directed graph. 
diff --git a/Java/Graph Valid Tree.java b/Java/Graph Valid Tree.java
@@ -1,8 +1,12 @@
-复习Union-Find的另外一个种形式。
-题目类型：查找2个元素是不是在一个set里面。如果不在，false. 如果在，那就合并成一个set,共享parent.
-存储的关键都是：元素相对的index上存着他的root parent.
+M
+
+复习Union-Find的另外一个种形式。   
+题目类型：查找2个元素是不是在一个set里面。如果不在，false. 如果在，那就合并成一个set,共享parent.   
+存储的关键都是：元素相对的index上存着他的root parent.    
 
 另一个union-find， 用hashmap的：http://www.lintcode.com/en/problem/find-the-weak-connected-component-in-the-directed-graph/
+
+
 ```
 /*
 Given n nodes labeled from 0 to n - 1 and a list of undirected edges (each edge is a pair of nodes), 
diff --git a/Java/Minimum Window Substring.java b/Java/Minimum Window Substring.java
@@ -39,6 +39,7 @@ Can you do it in time complexity O(n) ?
 /*
 03.09.2016
 http://blog.sina.com.cn/s/blog_eb52001d0102v2il.html
+http://www.rudy-yuan.net/archives/185/
 
 只利用一个hashmap save frequency of target.
 1. 从map里面 减去 source char match target char 的frequency. 如果发现frequency = 0, size++
diff --git a/Java/Number of Islands II.java b/Java/Number of Islands II.java
@@ -1,7 +1,16 @@
+H
+
+
+```
 /*
-Given a n,m which means the row and column of the 2D matrix and an array of pair A( size k). Originally, the 2D matrix is all 0 which means there is only sea in the matrix. The list pair has k operator and each operator has two integer A[i].x, A[i].y means that you can change the grid matrix[A[i].x][A[i].y] from sea to island. Return how many island are there in the matrix after each operator.
+Given a n,m which means the row and column of the 2D matrix and an array of pair A( size k). 
+Originally, the 2D matrix is all 0 which means there is only sea in the matrix. 
+The list pair has k operator and each operator has two integer A[i].x, A[i].y means 
+that you can change the grid matrix[A[i].x][A[i].y] from sea to island. 
+
+Return how many island are there in the matrix after each operator.
+
 
-Have you met this question in a real interview? Yes
 Example
 Given n = 3, m = 3, array of pair A = [(0,0),(0,1),(2,2),(2,1)].
 
@@ -108,3 +117,5 @@ public List<Integer> numIslands2(int n, int m, Point[] operators) {
     	return rst;
     }
 }
+
+```
diff --git a/Java/Topological Sorting.java b/Java/Topological Sorting.java
@@ -1,3 +1,21 @@
+M
+
+比较特别的BFS.
+
+几个graph的condition：   
+1. 可能有多个root
+2. directed node, 可以direct backwards.
+
+Steps:    
+Track all neighbors/childrens. 把所有的children都存在map<label, count>里面
+先把所有的root加一遍，可能多个root。并且全部加到queue里面。
+
+然后以process queue, do BFS:   
+Only when map.get(label) == 0, add into queue && rst.    
+这用map track apperance, 确保在后面出现的node, 一定最后process.
+
+
+```
 /*
 Given an directed graph, a topological order of the graph nodes is defined as follow:
 
@@ -51,40 +69,42 @@ public class Solution {
     public ArrayList<DirectedGraphNode> topSort(ArrayList<DirectedGraphNode> graph) {
         ArrayList<DirectedGraphNode> rst = new ArrayList<DirectedGraphNode>();
         if (graph == null || graph.size() == 0) {
-        	return graph;
+            return graph;
         }
-       	//Keep track of all neighbors in HashMap
+        //Keep track of all neighbors in HashMap
         HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
         for (DirectedGraphNode node : graph) {
-        	for (DirectedGraphNode neighbor : node.neighbors) {
-        		int keyN = neighbor.label;
-	        	if (map.containsKey(keyN)) {
-	        		map.put(keyN, map.get(keyN) + 1);
-	        	} else {
-	        		map.put(keyN, 1);
-	        	}
-        	}
+            for (DirectedGraphNode neighbor : node.neighbors) {
+                int keyN = neighbor.label;
+                if (map.containsKey(keyN)) {
+                    map.put(keyN, map.get(keyN) + 1);
+                } else {
+                    map.put(keyN, 1);
+                }
+            }
         }
         //BFS: Add root node. Note: 
         Queue<DirectedGraphNode> queue = new LinkedList<DirectedGraphNode>();
         for (DirectedGraphNode node : graph) {
-        	if (!map.containsKey(node.label)) {
-        		queue.offer(node);
-        		rst.add(node);
-        	}
+            if (!map.containsKey(node.label)) {
+                queue.offer(node);
+                rst.add(node);
+            }
         }
         //BFS: go through all children
         while (!queue.isEmpty()) {
-        	DirectedGraphNode node = queue.poll();	
-        	for (DirectedGraphNode n : node.neighbors) {
-        		int label = n.label;
-        		map.put(label, map.get(label) - 1);
-        		if (map.get(label) == 0) {
-        			rst.add(n);
-        			queue.offer(n);
-        		}
-        	}
+            DirectedGraphNode node = queue.poll();  
+            for (DirectedGraphNode n : node.neighbors) {
+                int label = n.label;
+                map.put(label, map.get(label) - 1);
+                if (map.get(label) == 0) {
+                    rst.add(n);
+                    queue.offer(n);
+                }
+            }
         }
         return rst;
     }
 }
+
+```
diff --git a/Java/Word Ladder II.java b/Java/Word Ladder II.java
diff --git a/Java/Word Ladder.java b/Java/Word Ladder.java
diff --git a/ReviewPage.md b/ReviewPage.md
diff --git a/knowledgeHash.json b/knowledgeHash.json
