fix some bugs

Author: hrwhisper

Diff for: 1_Divide_and_Conquer/readme.md

@@ -169,7 +169,7 @@ $$
 在平均情况下，我们选择的一般不是最好也不是最差。和快速排序的平均复杂度证明类似，本算法也可以证明平均复杂度为O(n)
 
 ## Problem 3.
-> Consider an n-node complete binary tree T, where n = 2^d^ − 1 for some d. Each node v of T is labeled with a real number xv. You may assume that the real numbers labeling the nodes are all distinct. A node v of T is a local minimum if the label x~v~ is less than the label x~w~ for all nodes w that are joined to v by an edge.
+> Consider an n-node complete binary tree T, where n = 2^d^ − 1 for some d. Each node v of T is labeled with a real number x~v~. You may assume that the real numbers labeling the nodes are all distinct. A node v of T is a local minimum if the label x~v~ is less than the label x~w~ for all nodes w that are joined to v by an edge.
 > You are given such a complete binary tree T, but the labeling is only specified in the following implicit way: for each node v, you can determine the value x~v~ by probing the node v. Show how to find a local minimum of T using only O(logn) probes to the nodes of T.
 
 ### 思路与代码
@@ -368,7 +368,7 @@ $$
 $$
 min(rocks[i] - rocks[i-1] , i ∈ [1,N + 1]) < = d <= L
 $$
-因此，我们可以用二分的方法猜测该最小距离。设当前的范围[left,right)。 每次我们查看 left 和 right的中点mid，该mid就是我们猜测的最小的距离的最大值，然后对rocks中，间距不大于mid的进行计数（这些就是要删除的点），记为cnt。
+因此，我们可以用二分的方法猜测该最小距离。设当前的范围[left,right)。 每次我们查看 left 和 right的中点mid，该mid就是我们猜测的最小的距离的最大值，然后对rocks中，间距**不大于**mid的进行计数（这些就是要删除的点），记为cnt。
 
 - cnt > M: 说明该mid值太大了，需要减小，区间变为 [left,mid)
 - cnt < M: 说明mid太小，区间变为 [mid+1,right)
@@ -399,7 +399,7 @@ def solve_largest_minimum_spacing(L, M, N, rocks):
     rocks = [0] + rocks + [L]
     N += 2
     rocks.sort()
-    left = min(rocks[i] - rocks[i - 1] for i in range(1, N))
+    left = min(rocks[i] - rocks[i - 1] for i in range(1, N)) # left start with 0 is ok.
     return binary_search(left, L + 1, rocks, M, N)
 
 # solve_largest_minimum_spacing(L, M, N, rocks)
@@ -430,7 +430,7 @@ def solve_largest_minimum_spacing(L, M, N, rocks):
 ## Problem 6.
 
 > Recall the problem of finding the number of inversions. As in the course, we are given a sequence of n numbers a1,··· ,an, which we assume are all distinct, and we difine an inversion to be a pair i < j such that ai > aj.
-> We motivated the problem of counting inversions as a good measure of how different two orderings are. However, one might feel that this measure is too sensitive. Let’s call a pair a significant inversion if i < j and ai > 3aj. Given an O(nlogn) algorithm to count the number of significant inversions between two orderings.
+> We motivated the problem of counting inversions as a good measure of how different two orderings are. However, one might feel that this measure is too sensitive. Let’s call a pair a significant inversion if i < j and ai > 3a~j~. Given an O(nlogn) algorithm to count the number of significant inversions between two orderings.
 
 ### 思路与代码
 

Diff for: 2_DP/5.py

@@ -4,13 +4,13 @@
 import collections
 
 
-def can_cross(stones):
+def can_cross2(stones):
     n = len(stones)
     val2id = {stone: i for i, stone in enumerate(stones)}
-    dp = collections.defaultdict(lambda :collections.defaultdict(int))
+    dp = collections.defaultdict(lambda: collections.defaultdict(int))
     dp[1][0] = True
     for j in range(1, n):
-        for i in dp[j]: # the same as dp[j].keys()
+        for i in dp[j]:  # the same as dp[j].keys()
             step = stones[j] - stones[i]
             for k in [step + 1, step, step - 1]:
                 _next = stones[j] + k
@@ -23,6 +23,17 @@ def can_cross(stones):
     return False
 
 
+def can_cross(stones):
+    dp = {stone: {} for stone in stones}
+    dp[0][0] = 0
+    for stone in stones:
+        for step in dp[stone].values():
+            for k in [step + 1, step, step - 1]:
+                if k > 0 and stone + k in dp:
+                    dp[stone + k][stone] = k
+    return len(dp[stones[-1]].keys()) > 0
+
+
 if __name__ == '__main__':
     print(can_cross([0, 2]))
     print(can_cross([0, 1, 3, 5, 6, 8, 12, 17]))

Diff for: 2_DP/readme.md

@@ -136,7 +136,7 @@ def rob_circle2(nums):
 
 该题正确性的证明在于对状态转移方程的正确性证明。
 
-对于i不抢，显然只能为dp[i-2]，而抢显然为dp[i-2] + nums[i]，因此我们只需要取其最大值即可。
+对于i不抢，显然只能为dp[i-1]，而抢显然为dp[i-2] + nums[i]，因此我们只需要取其最大值即可。
 
 环形情况同理。
 
@@ -151,10 +151,8 @@ def rob_circle2(nums):
 
 ## 3. Partition
 
-> Given a string s, partition s such that every substring of the partition is a palindrome. Return
-> the minimum cuts needed for a palindrome partitioning of s.
-> For example, given s = “aab", return 1 since the palindrome partitioning ["aa", "b"] could
-> be produced using 1 cut.
+> Given a string s, partition s such that every substring of the partition is a palindrome. Return the minimum cuts needed for a palindrome partitioning of s.
+> For example, given s = “aab", return 1 since the palindrome partitioning ["aa", "b"] could be produced using 1 cut.
 
 ### 问题分析（最优子结构及DP表达式）
 
@@ -282,7 +280,7 @@ def decoding_ways(s):
 
 > A frog is crossing a river. The river is divided into x units and at each unit there may or may not exist a stone. The frog can jump on a stone, but it must not jump into the water.
 >
-> If the frog’s last jump was k units, then its next jump must be either k −1,k, or k +1 units. Note that the frog can only jump in the forward direction.
+> If the frog’s last jump was k units, then its next jump must be either k −1, k, or k +1 units. Note that the frog can only jump in the forward direction.
 >
 > Given a list of stones’ positions (in units) in sorted ascending order, determine if the frog is able to cross the river by landing on the last stone. Initially, the frog is on the first stone and assume the first jump must be 1 unit.
 
@@ -292,9 +290,27 @@ def decoding_ways(s):
 
 因此对于到达了某一个点，我们可以查看其上一次是从哪个点跳过来的。
 
+设dp[ j ]\[ i ] 为从i到达j 的步数，初始时把所有的石头存放进hash表。然后设置dp\[0][0] = 0. 接着对于每个石头，从可以到达该石头的所有石头中取出步数k（k > 0），然后当前的stone + k看其是否是合法的石头，是的话就有d\[stone + k ][stone] = k
+
+```
+def can_cross(stones):
+    dp = {stone: {} for stone in stones}
+    dp[0][0] = 0
+    for stone in stones:
+        for step in dp[stone].values():
+            for k in [step + 1, step, step - 1]:
+                if k > 0 and stone + k in dp:
+                    dp[stone + k][stone] = k
+    return len(dp[stones[-1]].keys()) > 0
+```
+
+
+
+### 原来的方法
+
 设dp[ j ]\[ i ] 从i可以到达j，因此，对于点 j，我们只需要查看可以从哪个地方跳转过来（这里假设为i），然后查看其跳跃的距离$step = stones[j] - stones[i]$ , 则下一次的跳的距离为$step + 1, step, step - 1$ ，然后查看下一个点\_id存不存在（用Hash），存在将dp\[\_id][j] 设置为可达 ,若$\_id==n-1$，说明到达了对岸。这样复杂度为O(n^2^)
 
-### 代码
+#### 代码
 
 在具体的实现上，使用了类似邻接表的方式来加快速度。
 

Diff for: 2_DP/readme.pdf

@@ -7,7 +7,7 @@ def can_be_a_graph(degrees):
     d_sum, n = sum(degrees), len(degrees)
     if d_sum & 1 or n * (n - 1) < d_sum or max(degrees) > n - 1: return False
     for n in range(n, -1, -1):
-        degrees.sort(reverse=True) # 可以每一次算完类似合并排序合并过程使得总复杂度为O(n^2)
+        degrees.sort(reverse=True)  # 可以每一次算完类似合并排序合并过程使得总复杂度为O(n^2)
         for i in range(1, n):
             if degrees[0] <= 0: break
             degrees[i] -= 1
@@ -17,6 +17,44 @@ def can_be_a_graph(degrees):
     return True
 
 
+def merge(a, ls, le, re):
+    t = []
+    _ls = ls
+    rs = le
+    while ls < le and rs < re:
+        if a[ls] >= a[rs]:
+            t.append(a[ls])
+            ls += 1
+        else:
+            t.append(a[rs])
+            rs += 1
+    for i in range(ls, le):
+        t.append(a[i])
+    for i in range(rs, re):
+        t.append(a[i])
+
+    for i in range(_ls, re):
+        a[i] = t[i - _ls]
+
+
+def can_be_a_graph2(degrees):
+    d_sum, n = sum(degrees), len(degrees)
+    if d_sum & 1 or n * (n - 1) < d_sum or max(degrees) > n - 1: return False
+    degrees.sort(reverse=True)
+    while degrees:
+        k = degrees[0]
+        for i in range(1, n):
+            if degrees[0] <= 0: break
+            degrees[i] -= 1
+            if degrees[i] < 0: return False
+            degrees[0] -= 1
+        if degrees[0] != 0: return False
+        n -= 1
+        degrees.pop(0)
+        merge(degrees, 0, k, n)
+    return True
+
+
 if __name__ == '__main__':
     test_case = [
         [1, 1, 2, 2, 4],  # True
@@ -29,4 +67,4 @@ def can_be_a_graph(degrees):
     ]
 
     for t in test_case:
-        print(can_be_a_graph(t[:]))
+        print(can_be_a_graph(t[:]) , can_be_a_graph2(t[:]))

Diff for: 3_Greedy/1.py

@@ -24,7 +24,7 @@
 首先，判断满足如下条件：
 
 - 度数和为偶数 （对于无向图，每条边贡献两个度，因此度数和必为偶数）
-- 总边数不超过 $ \frac{n*(n-1)}{2} $ 在（完全的简单图，最大度不超过n-1）
+- 总边数不超过 $ \frac{n*(n-1)}{2} $ 在（完全的简单图，**最大度不超过n-1**）
 
 接着，我们每次排序（逆序），首先把最大的度数（设为k）安排出去，看看是否足够多的点（k个）来满足它需要的边（就是从前往后扫，每个度－1）。如果不够，说明只能安排重边，即不能构成简单图。
 
@@ -53,8 +53,6 @@ def can_be_a_graph(degrees):
 
 紧接着，我们每次排序（逆序），如果能构成简单的图，度数最大的点x（设度数为k）必然可以从其他较大的k个节点中连接一条边，因此如果有k个节点，那么不会有重边出现，这个点可以安排，如果不满足k个节点，显然不能构成简单图。
 
-
-
 ### 时间复杂度分析
 
 上述的做法，每次进行排序，每次排序复杂度为O(nlogn)，一共有n次排序，因此复杂度O(n^2^logn)
@@ -111,7 +109,7 @@ fte_i_k = fte = max(fte,pte+f[k])
 
 由于f[i] > f[k],那么有fte_k\_i > fte_k\_i\_1（因为f[i] > f[k]并且pte变大了）
 
-而 fte_i_k >= fte\_i\_k\_1（pte变大，但是fk] < f[i]），也就是说，交换i和k不会增大fte的值。
+而 fte_i_k >= fte\_i\_k\_1（pte变大，但是f[k] < f[i]），也就是说，交换i和k不会增大fte的值。
 
 因此，我们的贪心算法是正确的。
 
@@ -155,7 +153,7 @@ def min_radar(points, d):
     px = points[0].x + sqrt(d * d - points[0].y * points[0].y)
     ans = 1
     for i in range(1,len(points)):
-        if (px - points[i].x)**2 + points[i].y * points[i].y <= d*d: continue
+        if (px - points[i].x)**2 + points[i].y ** 2 <= d*d: continue
         cx = points[i].x + sqrt(d * d - points[i].y * points[i].y)
         if cx < px:
             px = cx

Diff for: 3_Greedy/readme.md

@@ -163,7 +163,7 @@ $$
 \end{array}\nonumber
 $$
 
-还没写完
+
 
 
 

Diff for: 4_LP/readme.md

@@ -131,7 +131,7 @@ def test(m, n, row, col):
 遍历E中的边，重复下述的过程：
 
 - 对于当前的边e~i~，将其容量+1
-- 继续运行最大流算法，得到新的最小割 C~i~ ， 其大小为|C~i~|
+- 继续运行最大流算法，得到新的最小割 C~i~ ， 其大小(即最大流流量)为|C~i~|
 - 若|C~i~| = |C|, 说明|C~i~| 也是最小割，就是说G的最小割不唯一，return False
 - 恢复e~i~ 的值
 
@@ -293,11 +293,13 @@ $$
 $$
 We add a 'weight'  which is called y~e~ for every edge. 
 
-The two constraints says every path has a non-negative weight and sum of  every path's weight must be at least 1. Actually, given a cut A-B(and $s \in A, t\in B​$) ,  if  edge e connect A and B(in other words,  $u \in A, v\in B\quad(u,v) ​$ is two vertices of edge e，and $ (u,v)​$ is  a cut edge ),we set  y~e~ = 1, otherwise, we set y~e~ = 0.
+The two constraints says every path has a non-negative weight and sum of  every path's weight must be at least 1. Actually, given a cut A-B(and $s \in A, t\in B$) ,  if  edge e connect A and B(in other words,  $u \in A, v\in B\quad(u,v) $ is two vertices of edge e，and $ (u,v)$ is  a cut edge ),we set  y~e~ = 1, otherwise, we set y~e~ = 0.
 
 So, the objective function is just to minimize the sum of capacity multiply its weight. Obviously, it is designed  to solve the minimum cut problem.
 
+目标函数中 $y_e$ 表示一条边选或者不选，为1选，为2不选，因此目标函数是求最小割。
 
+第一个约束条件表示从s到t中的路径，至少有一条边在割上。
 
 
 

Diff for: 5_Network_flow/Assignment5_NF.pdf

@@ -65,7 +65,7 @@ mine consistency problem = { \<G,φ> |给定图G以及部分周围地雷个数
 
 > In the Half-3SAT problem, we are given a 3SAT formula  with n variables and m clauses, where m is even. We wish to determine whether there exists an assignment to the variables of  such that exactly half the clauses evaluate to false and exactly half the clauses evaluate to true. Prove that Half-3SA problem is in NP-complete.
 
-首先，给定一个有m个子句的 Half-3SAT问题，显然，我们可以在多项式时间内判断其是否是可满足的，即是否有$\frac{m}{2}$个子句为真，$\frac{m}{2}$个子句为假，因此， Half-3SAT可以在多项式时间验证，它是NP问题。
+首先，给定一个有m个子句的 Half-3SAT问题以及n个变量的赋值，显然，我们可以在多项式时间内判断其是否是可满足的，即是否有$\frac{m}{2}$个子句为真，$\frac{m}{2}$个子句为假，因此， Half-3SAT可以在多项式时间验证，它是NP问题。
 
 为了证明Half-3SAT是NP完全问题，我们只需要证明 $3SAT \leq_p Half-3SAT$ 问题即可。
 
@@ -91,39 +91,44 @@ mine consistency problem = { \<G,φ> |给定图G以及部分周围地雷个数
 
 ## 4. Solitaire Game
 
-> In the following solitaire game, you are given an n X n board. On each of its n^2^ positions lies either a blue stone, a red stone, or nothing at all. You play by removing stones from the board so that each column contains only stones of a single color and each row contains at least one stone. You win if you achieve this objective.
+> In the following solitaire game, you are given an n x n board. On each of its n^2^ positions lies either a blue stone, a red stone, or nothing at all. You play by removing stones from the board so that each **column** contains **only stones of a single color** and each **row** contains **at least one stone**. You win if you achieve this objective.
 >
 > Winning may or may not be possible, depending upon the initial configuration. You must determine the given initial conguration is a winnable game configuration. Let **SOLITAIRE** = { \<G> |G is a winnable game configuration}. Prove that SOLITAIRE is NP-complete.
 
 首先，给定最终板子上的红色和蓝色石头的分布情况，我们只需要对每一列扫描，看其每一列是否颜色单一，然后对每一行扫描，看其每一行是否至少有一个石头。这只需要花费O(n^2^)的时间，因此Solitaire Game是NP问题。
 
 为了证明Solitaire Game是NP完全问题，我们只需要证明 $3SAT \leq_p Solitaire\quad Game$ 问题即可。
 
-对于一个3SAT问题，假设有N个变量，M个子句，那么我们设n = max(M,N)
+对于一个3SAT问题，假设有N个变量，M个子句，若 $N \ne M$：
+
+- N > M: 那么创建N - M个子句 $p \lor \neg p \lor q$的子句，这些子句不会对3SAT解照成影响。
+- N < M: 那么创建M - N个不会被使用的变量。
+
+接着我们设我们设n = max(M,N)，创建$n \times n$的板子。
 
 我们将每一行对应一个子句，每一列对应一个变量。对于子句中$x_i$的变量，我们用蓝色圆形石头表示，对于子句中$\neg x_i$的变量，我们用红色三角形的石头表示。
 
 因此，比如$ (x_1 \lor x_2 \lor\neg x_3)  \land  (x_3 \lor \neg x_4 \lor x_5) $ 如下图：
 
 ![4](./img/4.png)
 
-若变量$x_i = True$，我们移除红色三角形石头，否则，移除蓝色圆形石头。
+若变量$x_i$为True，我们移除红色三角形石头，否则，移除蓝色圆形石头。
 
 以$x_1 = True ,x_2 = True ,x_3 = False,x_4=True,x_5 =True $ 如下图所示
 
 ![4_true](./img/4_true.png)
 
 
 
-这个赋值在SAT是为真的，而我们的Solitaire Game同样可以为真，在下面的$t_3 , t_4,t_5$ 中，只需要保证每一行都有一个石头，该石头与该列赋值一致即可（如$x_1 = True$那么放置蓝色石头，$x_4 = True$放置红色石头）。
+这个赋值在SAT是为真的，而我们的Solitaire Game同样可以为真，在下面的$t_3 , t_4,t_5$ 中，只需要保证每一行都有一个石头，该石头与该列赋值一致即可（如$x_1 = True$那么放置蓝色石头，$x_3 = False$放置红色石头）。
 
 而3SAT赋值为假的情况又如何呢？$x_1 = False,x_2 = False,x_3 = True,x_4=True,x_5 =False$为使得$ (x_1 \lor x_2 \lor\neg x_3)  \land  (x_3 \lor \neg x_4 \lor x_5) $ 为假的一组赋值。移除对应的石头有：
 
 ![4_false](./img/4_false.png)
 
-而无论下面的$t_3 , t_4,t_5$ 如何赋值，第一行都是空的，不符合条件，Solitaire Game无解。
+而无论下面的$t_3 , t_4,t_5​$ 如何赋值，第一行都是空的，不符合条件，Solitaire Game无解。
 
-其实上述的移除石头的过程原理是：用列来保证只有一种颜色（要么赋值为真-蓝色，要么赋值为假-红色），而用行来保证每行至少有一个石头（该变量为真石头得到保留）。
+其实上述的移除石头的过程原理是：**用列来保证只有一种颜色**（要么赋值为真-蓝色，要么赋值为假-红色），而**用行来保证每行至少有一个石头**（该变量为真石头得到保留）。
 
 因此有$3SAT \leq_p Solitaire\quad Game$  ，所以Solitaire Game是NP完全问题。
 

Diff for: 5_Network_flow/readme.md

@@ -23,7 +23,7 @@
 
 ## 支持
 
-觉得好的话可以点击 **star**支持 或者**打赏**一点馒头钱=v=
+觉得好的话可以点击 **star**支持 、**打赏**一点馒头钱=v=