fix some bugs

Author: hrwhisper

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.
 
 ### 思路与代码
 

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]))

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^)
 
-### 代码
+#### 代码
 
 在具体的实现上，使用了类似邻接表的方式来加快速度。
 

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[:]))

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

3_Greedy/readme.md

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

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中的路径，至少有一条边在割上。