CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-02-12 23:25:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-11-17 00:35:19 +08:00
parent c7794e1a84
commit 5ae2d5e925
17 changed files with 229 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
docs/chapter_dynamic_programming/dp_problem_features.md
View File

@@ -264,15 +264,18 @@ $$
if (n == 1 || n == 2)
return cost[n];
// 初始化 dp 表，用于存储子问题的解
int dp[n + 1];
int *dp = calloc(n + 1, sizeof(int));
// 初始状态：预设最小子问题的解
dp[1] = cost[1];
dp[2] = cost[2];
// 状态转移：从较小子问题逐步求解较大子问题
for (int i = 3; i <= n; i++) {
dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
dp[i] = myMin(dp[i - 1], dp[i - 2]) + cost[i];
}
return dp[n];
int res = dp[n];
// 释放内存
free(dp);
return res;
}
```
@@ -503,7 +506,7 @@ $$
int a = cost[1], b = cost[2];
for (int i = 3; i <= n; i++) {
int tmp = b;
b = min(a, tmp) + cost[i];
b = myMin(a, tmp) + cost[i];
a = tmp;
}
return b;
@@ -815,8 +818,10 @@ $$
return 1;
}
// 初始化 dp 表，用于存储子问题的解
int dp[n + 1][3];
memset(dp, 0, sizeof(dp));
int **dp = malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
dp[i] = calloc(3, sizeof(int));
}
// 初始状态：预设最小子问题的解
dp[1][1] = 1;
dp[1][2] = 0;
@@ -827,7 +832,13 @@ $$
dp[i][1] = dp[i - 1][2];
dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
}
return dp[n][1] + dp[n][2];
int res = dp[n][1] + dp[n][2];
// 释放内存
for (int i = 0; i <= n; i++) {
free(dp[i]);
}
free(dp);
return res;
}
```

43
docs/chapter_dynamic_programming/dp_solution_pipeline.md
View File

@@ -326,7 +326,7 @@ $$
```c title="min_path_sum.c"
/* 最小路径和：暴力搜索 */
int minPathSumDFS(int gridCols, int grid[][gridCols], int i, int j) {
int minPathSumDFS(int grid[MAX_SIZE][MAX_SIZE], int i, int j) {
// 若为左上角单元格，则终止搜索
if (i == 0 && j == 0) {
return grid[0][0];
@@ -336,10 +336,10 @@ $$
return INT_MAX;
}
// 计算从左上角到 (i-1, j) 和 (i, j-1) 的最小路径代价
int up = minPathSumDFS(gridCols, grid, i - 1, j);
int left = minPathSumDFS(gridCols, grid, i, j - 1);
int up = minPathSumDFS(grid, i - 1, j);
int left = minPathSumDFS(grid, i, j - 1);
// 返回从左上角到 (i, j) 的最小路径代价
return min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;
return myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;
}
```
@@ -646,7 +646,7 @@ $$
```c title="min_path_sum.c"
/* 最小路径和：记忆化搜索 */
int minPathSumDFSMem(int gridCols, int grid[][gridCols], int mem[][gridCols], int i, int j) {
int minPathSumDFSMem(int grid[MAX_SIZE][MAX_SIZE], int mem[MAX_SIZE][MAX_SIZE], int i, int j) {
// 若为左上角单元格，则终止搜索
if (i == 0 && j == 0) {
return grid[0][0];
@@ -660,10 +660,10 @@ $$
return mem[i][j];
}
// 左边和上边单元格的最小路径代价
int up = minPathSumDFSMem(gridCols, grid, mem, i - 1, j);
int left = minPathSumDFSMem(gridCols, grid, mem, i, j - 1);
int up = minPathSumDFSMem(grid, mem, i - 1, j);
int left = minPathSumDFSMem(grid, mem, i, j - 1);
// 记录并返回左上角到 (i, j) 的最小路径代价
mem[i][j] = min(left, up) != INT_MAX ? min(left, up) + grid[i][j] : INT_MAX;
mem[i][j] = myMin(left, up) != INT_MAX ? myMin(left, up) + grid[i][j] : INT_MAX;
return mem[i][j];
}
```
@@ -984,9 +984,12 @@ $$
```c title="min_path_sum.c"
/* 最小路径和：动态规划 */
int minPathSumDP(int gridCols, int grid[][gridCols], int n, int m) {
int minPathSumDP(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {
// 初始化 dp 表
int dp[n][m];
int **dp = malloc(n * sizeof(int *));
for (int i = 0; i < n; i++) {
dp[i] = calloc(m, sizeof(int));
}
dp[0][0] = grid[0][0];
// 状态转移：首行
for (int j = 1; j < m; j++) {
@@ -999,10 +1002,15 @@ $$
// 状态转移：其余行列
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
dp[i][j] = myMin(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
}
}
return dp[n - 1][m - 1];
int res = dp[n - 1][m - 1];
// 释放内存
for (int i = 0; i < n; i++) {
free(dp[i]);
}
return res;
}
```
@@ -1344,9 +1352,9 @@ $$
```c title="min_path_sum.c"
/* 最小路径和：空间优化后的动态规划 */
int minPathSumDPComp(int gridCols, int grid[][gridCols], int n, int m) {
int minPathSumDPComp(int grid[MAX_SIZE][MAX_SIZE], int n, int m) {
// 初始化 dp 表
int dp[m];
int *dp = calloc(m, sizeof(int));
// 状态转移：首行
dp[0] = grid[0][0];
for (int j = 1; j < m; j++) {
@@ -1358,10 +1366,13 @@ $$
dp[0] = dp[0] + grid[i][0];
// 状态转移：其余列
for (int j = 1; j < m; j++) {
dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];
dp[j] = myMin(dp[j - 1], dp[j]) + grid[i][j];
}
}
return dp[m - 1];
int res = dp[m - 1];
// 释放内存
free(dp);
return res;
}
```

25
docs/chapter_dynamic_programming/edit_distance_problem.md
View File

@@ -387,8 +387,10 @@ $$
```c title="edit_distance.c"
/* 编辑距离：动态规划 */
int editDistanceDP(char *s, char *t, int n, int m) {
int dp[n + 1][m + 1];
memset(dp, 0, sizeof(dp));
int **dp = malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
dp[i] = calloc(m + 1, sizeof(int));
}
// 状态转移：首行首列
for (int i = 1; i <= n; i++) {
dp[i][0] = i;
@@ -404,11 +406,16 @@ $$
dp[i][j] = dp[i - 1][j - 1];
} else {
// 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
dp[i][j] = myMin(myMin(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
}
}
}
return dp[n][m];
int res = dp[n][m];
// 释放内存
for (int i = 0; i <= n; i++) {
free(dp[i]);
}
return res;
}
```
@@ -832,8 +839,7 @@ $$
```c title="edit_distance.c"
/* 编辑距离：空间优化后的动态规划 */
int editDistanceDPComp(char *s, char *t, int n, int m) {
int dp[m + 1];
memset(dp, 0, sizeof(dp));
int *dp = calloc(m + 1, sizeof(int));
// 状态转移：首行
for (int j = 1; j <= m; j++) {
dp[j] = j;
@@ -851,12 +857,15 @@ $$
dp[j] = leftup;
} else {
// 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;
dp[j] = myMin(myMin(dp[j - 1], dp[j]), leftup) + 1;
}
leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
}
}
return dp[m];
int res = dp[m];
// 释放内存
free(dp);
return res;
}
```

31
docs/chapter_dynamic_programming/knapsack_problem.md
View File

@@ -291,7 +291,7 @@ $$
int no = knapsackDFS(wgt, val, i - 1, c);
int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
// 返回两种方案中价值更大的那一个
return max(no, yes);
return myMax(no, yes);
}
```
@@ -606,7 +606,7 @@ $$
```c title="knapsack.c"
/* 0-1 背包：记忆化搜索 */
int knapsackDFSMem(int wgt[], int val[], int memCols, int mem[][memCols], int i, int c) {
int knapsackDFSMem(int wgt[], int val[], int memCols, int **mem, int i, int c) {
// 若已选完所有物品或背包无容量，则返回价值 0
if (i == 0 || c == 0) {
return 0;
@@ -623,7 +623,7 @@ $$
int no = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c);
int yes = knapsackDFSMem(wgt, val, memCols, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
// 记录并返回两种方案中价值更大的那一个
mem[i][c] = max(no, yes);
mem[i][c] = myMax(no, yes);
return mem[i][c];
}
```
@@ -924,8 +924,10 @@ $$
int knapsackDP(int wgt[], int val[], int cap, int wgtSize) {
int n = wgtSize;
// 初始化 dp 表
int dp[n + 1][cap + 1];
memset(dp, 0, sizeof(dp));
int **dp = malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
dp[i] = calloc(cap + 1, sizeof(int));
}
// 状态转移
for (int i = 1; i <= n; i++) {
for (int c = 1; c <= cap; c++) {
@@ -934,11 +936,16 @@ $$
dp[i][c] = dp[i - 1][c];
} else {
// 不选和选物品 i 这两种方案的较大值
dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
dp[i][c] = myMax(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
}
}
}
return dp[n][cap];
int res = dp[n][cap];
// 释放内存
for (int i = 0; i <= n; i++) {
free(dp[i]);
}
return res;
}
```
@@ -1278,19 +1285,21 @@ $$
int knapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {
int n = wgtSize;
// 初始化 dp 表
int dp[cap + 1];
memset(dp, 0, sizeof(dp));
int *dp = calloc(cap + 1, sizeof(int));
// 状态转移
for (int i = 1; i <= n; i++) {
// 倒序遍历
for (int c = cap; c >= 1; c--) {
if (wgt[i - 1] <= c) {
// 不选和选物品 i 这两种方案的较大值
dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
}
}
}
return dp[cap];
int res = dp[cap];
// 释放内存
free(dp);
return res;
}
```

73
docs/chapter_dynamic_programming/unbounded_knapsack_problem.md
View File

@@ -298,8 +298,10 @@ $$
int unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {
int n = wgtSize;
// 初始化 dp 表
int dp[n + 1][cap + 1];
memset(dp, 0, sizeof(dp));
int **dp = malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
dp[i] = calloc(cap + 1, sizeof(int));
}
// 状态转移
for (int i = 1; i <= n; i++) {
for (int c = 1; c <= cap; c++) {
@@ -308,11 +310,16 @@ $$
dp[i][c] = dp[i - 1][c];
} else {
// 不选和选物品 i 这两种方案的较大值
dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
}
}
}
return dp[n][cap];
int res = dp[n][cap];
// 释放内存
for (int i = 0; i <= n; i++) {
free(dp[i]);
}
return res;
}
```
@@ -616,8 +623,7 @@ $$
int unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {
int n = wgtSize;
// 初始化 dp 表
int dp[cap + 1];
memset(dp, 0, sizeof(dp));
int *dp = calloc(cap + 1, sizeof(int));
// 状态转移
for (int i = 1; i <= n; i++) {
for (int c = 1; c <= cap; c++) {
@@ -626,11 +632,14 @@ $$
dp[c] = dp[c];
} else {
// 不选和选物品 i 这两种方案的较大值
dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
dp[c] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
}
}
}
return dp[cap];
int res = dp[cap];
// 释放内存
free(dp);
return res;
}
```
@@ -1012,8 +1021,10 @@ $$
int n = coinsSize;
int MAX = amt + 1;
// 初始化 dp 表
int dp[n + 1][amt + 1];
memset(dp, 0, sizeof(dp));
int **dp = malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
dp[i] = calloc(amt + 1, sizeof(int));
}
// 状态转移：首行首列
for (int a = 1; a <= amt; a++) {
dp[0][a] = MAX;
@@ -1026,11 +1037,17 @@ $$
dp[i][a] = dp[i - 1][a];
} else {
// 不选和选硬币 i 这两种方案的较小值
dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
dp[i][a] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
}
}
}
return dp[n][amt] != MAX ? dp[n][amt] : -1;
int res = dp[n][amt] != MAX ? dp[n][amt] : -1;
// 释放内存
for (int i = 0; i <= n; i++) {
free(dp[i]);
}
free(dp);
return res;
}
```
@@ -1394,8 +1411,7 @@ $$
int n = coinsSize;
int MAX = amt + 1;
// 初始化 dp 表
int dp[amt + 1];
memset(dp, MAX, sizeof(dp));
int *dp = calloc(amt + 1, sizeof(int));
dp[0] = 0;
// 状态转移
for (int i = 1; i <= n; i++) {
@@ -1405,11 +1421,14 @@ $$
dp[a] = dp[a];
} else {
// 不选和选硬币 i 这两种方案的较小值
dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);
dp[a] = myMin(dp[a], dp[a - coins[i - 1]] + 1);
}
}
}
return dp[amt] != MAX ? dp[amt] : -1;
int res = dp[amt] != MAX ? dp[amt] : -1;
// 释放内存
free(dp);
return res;
}
```
@@ -1757,8 +1776,10 @@ $$
int coinChangeIIDP(int coins[], int amt, int coinsSize) {
int n = coinsSize;
// 初始化 dp 表
int dp[n + 1][amt + 1];
memset(dp, 0, sizeof(dp));
int **dp = malloc((n + 1) * sizeof(int *));
for (int i = 0; i <= n; i++) {
dp[i] = calloc(amt + 1, sizeof(int));
}
// 初始化首列
for (int i = 0; i <= n; i++) {
dp[i][0] = 1;
@@ -1775,7 +1796,13 @@ $$
}
}
}
return dp[n][amt];
int res = dp[n][amt];
// 释放内存
for (int i = 0; i <= n; i++) {
free(dp[i]);
}
free(dp);
return res;
}
```
@@ -2066,8 +2093,7 @@ $$
int coinChangeIIDPComp(int coins[], int amt, int coinsSize) {
int n = coinsSize;
// 初始化 dp 表
int dp[amt + 1];
memset(dp, 0, sizeof(dp));
int *dp = calloc(amt + 1, sizeof(int));
dp[0] = 1;
// 状态转移
for (int i = 1; i <= n; i++) {
@@ -2081,7 +2107,10 @@ $$
}
}
}
return dp[amt];
int res = dp[amt];
// 释放内存
free(dp);
return res;
}
```