modify code

Author: algorithmzuo

ppt/算法讲解083【必备】动态规划中用观察优化枚举的技巧-下.pptx

@@ -24,11 +24,12 @@ public static int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
 			jobs[i][1] = endTime[i];
 			jobs[i][2] = profit[i];
 		}
+		// 工作按照结束时间从小到大排序
 		Arrays.sort(jobs, 0, n, (a, b) -> a[1] - b[1]);
 		dp[0] = jobs[0][2];
 		for (int i = 1, start; i < n; i++) {
-			dp[i] = jobs[i][2];
 			start = jobs[i][0];
+			dp[i] = jobs[i][2];
 			if (jobs[0][1] <= start) {
 				dp[i] += dp[find(i - 1, start)];
 			}

src/class083/Code01_MaximumProfitInJobScheduling.java

@@ -14,6 +14,7 @@ public class Code02_KInversePairsArray {
 	// 不优化枚举
 	public static int kInversePairs1(int n, int k) {
 		int mod = 1000000007;
+		// dp[i][j] : 1、2、3...i这些数字，形成的排列一定要有j个逆序对，请问这样的排列有几种
 		int[][] dp = new int[n + 1][k + 1];
 		dp[0][0] = 1;
 		for (int i = 1; i <= n; i++) {
@@ -24,6 +25,7 @@ public static int kInversePairs1(int n, int k) {
 						dp[i][j] = (dp[i][j] + dp[i - 1][p]) % mod;
 					}
 				} else {
+					// i <= j
 					for (int p = j - i + 1; p <= j; p++) {
 						dp[i][j] = (dp[i][j] + dp[i - 1][p]) % mod;
 					}
@@ -49,6 +51,7 @@ public static int kInversePairs2(int n, int k) {
 				if (i > j) {
 					window = (window + dp[i - 1][j]) % mod;
 				} else {
+					// i <= j
 					window = ((window + dp[i - 1][j]) % mod - dp[i - 1][j - i] + mod) % mod;
 				}
 				dp[i][j] = window;

src/class083/Code02_KInversePairsArray.java

@@ -50,32 +50,48 @@ public static int findRotateSteps(String r, String k) {
 		return f(0, 0);
 	}
 
+	// 指针当前指着轮盘i位置的字符，要搞定key[j....]所有字符，最小代价返回
 	public static int f(int i, int j) {
 		if (j == m) {
+			// key长度是m
+			// 都搞定
 			return 0;
 		}
 		if (dp[i][j] != -1) {
 			return dp[i][j];
 		}
 		int ans;
 		if (ring[i] == key[j]) {
+			// ring b
+			//      i
+			// key  b
+			//      j
 			ans = 1 + f(i, j + 1);
 		} else {
+			// 轮盘处在i位置，ring[i] != key[j]
+			// jump1 : 顺时针找到最近的key[j]字符在轮盘的什么位置
+			// distance1 : 从i顺时针走向jump1有多远
 			int jump1 = clock(i, key[j]);
+			int distance1 = (jump1 > i ? (jump1 - i) : (n - i + jump1));
+			// jump2 : 逆时针找到最近的key[j]字符在轮盘的什么位置
+			// distance2 : 从i逆时针走向jump2有多远
 			int jump2 = counterClock(i, key[j]);
-			int p1 = (jump1 > i ? (jump1 - i) : (n - i + jump1)) + f(jump1, j);
-			int p2 = (i > jump2 ? (i - jump2) : (i + n - jump2)) + f(jump2, j);
-			ans = Math.min(p1, p2);
+			int distance2 = (i > jump2 ? (i - jump2) : (i + n - jump2));
+			ans = Math.min(distance1 + f(jump1, j), distance2 + f(jump2, j));
 		}
 		dp[i][j] = ans;
 		return ans;
 	}
 
+	// 从i开始，顺时针找到最近的v在轮盘的什么位置
 	public static int clock(int i, int v) {
 		int l = 0;
+		// size[v] : 属于v这个字符的下标有几个
 		int r = size[v] - 1, m;
+		// sorted[0...size[v]-1]收集了所有的下标，并且有序
 		int[] sorted = where[v];
 		int find = -1;
+		// 有序数组中，找>i尽量靠左的下标
 		while (l <= r) {
 			m = (l + r) / 2;
 			if (sorted[m] > i) {
@@ -85,6 +101,8 @@ public static int clock(int i, int v) {
 				l = m + 1;
 			}
 		}
+		// 找到了就返回
+		// 没找到，那i顺指针一定先走到最小的下标
 		return find != -1 ? sorted[find] : sorted[0];
 	}
 
@@ -93,6 +111,7 @@ public static int counterClock(int i, int v) {
 		int r = size[v] - 1, m;
 		int[] sorted = where[v];
 		int find = -1;
+		// 有序数组中，找<i尽量靠右的下标
 		while (l <= r) {
 			m = (l + r) / 2;
 			if (sorted[m] < i) {
@@ -102,6 +121,8 @@ public static int counterClock(int i, int v) {
 				r = m - 1;
 			}
 		}
+		// 找到了就返回
+		// 没找到，那i逆指针一定先走到最大的下标
 		return find != -1 ? sorted[find] : sorted[size[v] - 1];
 	}
 

src/class083/Code03_FreedomTrail.java

@@ -51,7 +51,9 @@ public static void main(String[] args) throws IOException {
 	public static int compute1() {
 		int[] sums = new int[n + 1];
 		for (int i = 0, sum = 0; i < n; i++) {
+			// sum : 0...i范围上，这前i+1个数字的累加和
 			sum += nums[i];
+			// sums[i + 1] : 前i+1个，包括一个数字也没有的时候，所有前缀和中的最大值
 			sums[i + 1] = Math.max(sum, sums[i]);
 		}
 		int ans = 0;
@@ -99,10 +101,15 @@ public static int compute2() {
 				sum += minSums[end];
 				end = minSumEnds[end] + 1;
 			}
-			ans = Math.max(ans, end - i);
 			if (end > i) {
+				// 如果end > i，
+				// 窗口范围：i...end-1，那么窗口有效
+				ans = Math.max(ans, end - i);
 				sum -= nums[i];
 			} else {
+				// 如果end == i，那么说明窗口根本没扩出来，代表窗口无效
+				// end来到i+1位置，然后i++了
+				// 继续以新的i位置做开头去扩窗口
 				end = i + 1;
 			}
 		}