mirror of
https://github.com/krahets/hello-algo.git
synced 2024-12-26 12:36:30 +08:00
build
This commit is contained in:
krahets
parent
c7794e1a84
commit
5ae2d5e925
17 changed files with 229 additions and 178 deletions
|
|
@ -410,14 +410,14 @@ comments: true
|
|||
=== "Dart"
|
||||
|
||||
```dart title="array.dart"
|
||||
/* 在数组的索引 index 处插入元素 num */
|
||||
void insert(List<int> nums, int num, int index) {
|
||||
/* 在数组的索引 index 处插入元素 _num */
|
||||
void insert(List<int> nums, int _num, int index) {
|
||||
// 把索引 index 以及之后的所有元素向后移动一位
|
||||
for (var i = nums.length - 1; i > index; i--) {
|
||||
nums[i] = nums[i - 1];
|
||||
}
|
||||
// 将 num 赋给 index 处元素
|
||||
nums[index] = num;
|
||||
// 将 _num 赋给 index 处元素
|
||||
nums[index] = _num;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -779,12 +779,12 @@ comments: true
|
|||
count += nums[i];
|
||||
}
|
||||
// 直接遍历数组元素
|
||||
for (int num in nums) {
|
||||
count += num;
|
||||
for (int _num in nums) {
|
||||
count += _num;
|
||||
}
|
||||
// 通过 forEach 方法遍历数组
|
||||
nums.forEach((num) {
|
||||
count += num;
|
||||
nums.forEach((_num) {
|
||||
count += _num;
|
||||
});
|
||||
}
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1713,22 +1713,22 @@ comments: true
|
|||
}
|
||||
|
||||
/* 更新元素 */
|
||||
void set(int index, int num) {
|
||||
void set(int index, int _num) {
|
||||
if (index >= _size) throw RangeError('索引越界');
|
||||
_arr[index] = num;
|
||||
_arr[index] = _num;
|
||||
}
|
||||
|
||||
/* 尾部添加元素 */
|
||||
void add(int num) {
|
||||
void add(int _num) {
|
||||
// 元素数量超出容量时，触发扩容机制
|
||||
if (_size == _capacity) extendCapacity();
|
||||
_arr[_size] = num;
|
||||
_arr[_size] = _num;
|
||||
// 更新元素数量
|
||||
_size++;
|
||||
}
|
||||
|
||||
/* 中间插入元素 */
|
||||
void insert(int index, int num) {
|
||||
void insert(int index, int _num) {
|
||||
if (index >= _size) throw RangeError('索引越界');
|
||||
// 元素数量超出容量时，触发扩容机制
|
||||
if (_size == _capacity) extendCapacity();
|
||||
|
|
@ -1736,7 +1736,7 @@ comments: true
|
|||
for (var j = _size - 1; j >= index; j--) {
|
||||
_arr[j + 1] = _arr[j];
|
||||
}
|
||||
_arr[index] = num;
|
||||
_arr[index] = _num;
|
||||
// 更新元素数量
|
||||
_size++;
|
||||
}
|
||||
|
|
@ -1744,7 +1744,7 @@ comments: true
|
|||
/* 删除元素 */
|
||||
int remove(int index) {
|
||||
if (index >= _size) throw RangeError('索引越界');
|
||||
int num = _arr[index];
|
||||
int _num = _arr[index];
|
||||
// 将索引 index 之后的元素都向前移动一位
|
||||
for (var j = index; j < _size - 1; j++) {
|
||||
_arr[j] = _arr[j + 1];
|
||||
|
|
@ -1752,7 +1752,7 @@ comments: true
|
|||
// 更新元素数量
|
||||
_size--;
|
||||
// 返回被删除元素
|
||||
return num;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* 列表扩容 */
|
||||
|
|
|
|||
|
|
@ -1394,7 +1394,7 @@ $$
|
|||
int arrayTraversal(List<int> nums) {
|
||||
int count = 0;
|
||||
// 循环次数与数组长度成正比
|
||||
for (var num in nums) {
|
||||
for (var _num in nums) {
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -355,8 +355,8 @@ $$
|
|||
// 循环贪心选择，直至两板相遇
|
||||
while (i < j) {
|
||||
// 更新最大容量
|
||||
int capacity = MIN(ht[i], ht[j]) * (j - i);
|
||||
res = MAX(res, capacity);
|
||||
int capacity = myMin(ht[i], ht[j]) * (j - i);
|
||||
res = myMax(res, capacity);
|
||||
// 向内移动短板
|
||||
if (ht[i] < ht[j]) {
|
||||
i++;
|
||||
|
|
|
|||
|
|
@ -392,7 +392,7 @@ comments: true
|
|||
int *topKHeap(int *nums, int sizeNums, int k) {
|
||||
// 初始化小顶堆
|
||||
// 请注意：我们将堆中所有元素取反，从而用大顶堆来模拟小顶堆
|
||||
int empty[0];
|
||||
int *empty = (int *)malloc(0);
|
||||
MaxHeap *maxHeap = newMaxHeap(empty, 0);
|
||||
// 将数组的前 k 个元素入堆
|
||||
for (int i = 0; i < k; i++) {
|
||||
|
|
|
|||
|
|
@ -283,11 +283,11 @@ comments: true
|
|||
List<List<double>> buckets = List.generate(k, (index) => []);
|
||||
|
||||
// 1. 将数组元素分配到各个桶中
|
||||
for (double num in nums) {
|
||||
// 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
|
||||
int i = (num * k).toInt();
|
||||
// 将 num 添加进桶 bucket_idx
|
||||
buckets[i].add(num);
|
||||
for (double _num in nums) {
|
||||
// 输入数据范围 [0, 1)，使用 _num * k 映射到索引范围 [0, k-1]
|
||||
int i = (_num * k).toInt();
|
||||
// 将 _num 添加进桶 bucket_idx
|
||||
buckets[i].add(_num);
|
||||
}
|
||||
// 2. 对各个桶执行排序
|
||||
for (List<double> bucket in buckets) {
|
||||
|
|
@ -296,8 +296,8 @@ comments: true
|
|||
// 3. 遍历桶合并结果
|
||||
int i = 0;
|
||||
for (List<double> bucket in buckets) {
|
||||
for (double num in bucket) {
|
||||
nums[i++] = num;
|
||||
for (double _num in bucket) {
|
||||
nums[i++] = _num;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -238,20 +238,20 @@ comments: true
|
|||
void countingSortNaive(List<int> nums) {
|
||||
// 1. 统计数组最大元素 m
|
||||
int m = 0;
|
||||
for (int num in nums) {
|
||||
m = max(m, num);
|
||||
for (int _num in nums) {
|
||||
m = max(m, _num);
|
||||
}
|
||||
// 2. 统计各数字的出现次数
|
||||
// counter[num] 代表 num 的出现次数
|
||||
// counter[_num] 代表 _num 的出现次数
|
||||
List<int> counter = List.filled(m + 1, 0);
|
||||
for (int num in nums) {
|
||||
counter[num]++;
|
||||
for (int _num in nums) {
|
||||
counter[_num]++;
|
||||
}
|
||||
// 3. 遍历 counter ，将各元素填入原数组 nums
|
||||
int i = 0;
|
||||
for (int num = 0; num < m + 1; num++) {
|
||||
for (int j = 0; j < counter[num]; j++, i++) {
|
||||
nums[i] = num;
|
||||
for (int _num = 0; _num < m + 1; _num++) {
|
||||
for (int j = 0; j < counter[_num]; j++, i++) {
|
||||
nums[i] = _num;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -666,17 +666,17 @@ $$
|
|||
void countingSort(List<int> nums) {
|
||||
// 1. 统计数组最大元素 m
|
||||
int m = 0;
|
||||
for (int num in nums) {
|
||||
m = max(m, num);
|
||||
for (int _num in nums) {
|
||||
m = max(m, _num);
|
||||
}
|
||||
// 2. 统计各数字的出现次数
|
||||
// counter[num] 代表 num 的出现次数
|
||||
// counter[_num] 代表 _num 的出现次数
|
||||
List<int> counter = List.filled(m + 1, 0);
|
||||
for (int num in nums) {
|
||||
counter[num]++;
|
||||
for (int _num in nums) {
|
||||
counter[_num]++;
|
||||
}
|
||||
// 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
|
||||
// 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
|
||||
// 即 counter[_num]-1 是 _num 在 res 中最后一次出现的索引
|
||||
for (int i = 0; i < m; i++) {
|
||||
counter[i + 1] += counter[i];
|
||||
}
|
||||
|
|
@ -685,9 +685,9 @@ $$
|
|||
int n = nums.length;
|
||||
List<int> res = List.filled(n, 0);
|
||||
for (int i = n - 1; i >= 0; i--) {
|
||||
int num = nums[i];
|
||||
res[counter[num] - 1] = num; // 将 num 放置到对应索引处
|
||||
counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
|
||||
int _num = nums[i];
|
||||
res[counter[_num] - 1] = _num; // 将 _num 放置到对应索引处
|
||||
counter[_num]--; // 令前缀和自减 1 ，得到下次放置 _num 的索引
|
||||
}
|
||||
// 使用结果数组 res 覆盖原数组 nums
|
||||
nums.setAll(0, res);
|
||||
|
|
|
|||
|
|
@ -465,10 +465,10 @@ $$
|
|||
=== "Dart"
|
||||
|
||||
```dart title="radix_sort.dart"
|
||||
/* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
|
||||
int digit(int num, int exp) {
|
||||
/* 获取元素 _num 的第 k 位，其中 exp = 10^(k-1) */
|
||||
int digit(int _num, int exp) {
|
||||
// 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
|
||||
return (num ~/ exp) % 10;
|
||||
return (_num ~/ exp) % 10;
|
||||
}
|
||||
|
||||
/* 计数排序（根据 nums 第 k 位排序） */
|
||||
|
|
@ -502,7 +502,7 @@ $$
|
|||
// 获取数组的最大元素，用于判断最大位数
|
||||
// dart 中 int 的长度是 64 位的
|
||||
int m = -1 << 63;
|
||||
for (int num in nums) if (num > m) m = num;
|
||||
for (int _num in nums) if (_num > m) m = _num;
|
||||
// 按照从低位到高位的顺序遍历
|
||||
for (int exp = 1; exp <= m; exp *= 10)
|
||||
// 对数组元素的第 k 位执行计数排序
|
||||
|
|
|
|||
|
|
@ -1417,8 +1417,8 @@ comments: true
|
|||
}
|
||||
|
||||
/* 入队操作 */
|
||||
void push(int num, bool isFront) {
|
||||
final ListNode node = ListNode(num);
|
||||
void push(int _num, bool isFront) {
|
||||
final ListNode node = ListNode(_num);
|
||||
if (isEmpty()) {
|
||||
// 若链表为空，则令 _front 和 _rear 都指向 node
|
||||
_front = _rear = node;
|
||||
|
|
@ -1439,13 +1439,13 @@ comments: true
|
|||
}
|
||||
|
||||
/* 队首入队 */
|
||||
void pushFirst(int num) {
|
||||
push(num, true);
|
||||
void pushFirst(int _num) {
|
||||
push(_num, true);
|
||||
}
|
||||
|
||||
/* 队尾入队 */
|
||||
void pushLast(int num) {
|
||||
push(num, false);
|
||||
void pushLast(int _num) {
|
||||
push(_num, false);
|
||||
}
|
||||
|
||||
/* 出队操作 */
|
||||
|
|
@ -1831,7 +1831,7 @@ comments: true
|
|||
|
||||
/* 打印队列 */
|
||||
void printLinkedListDeque(LinkedListDeque *deque) {
|
||||
int arr[deque->queSize];
|
||||
int *arr = malloc(sizeof(int) * deque->queSize);
|
||||
// 拷贝链表中的数据到数组
|
||||
int i;
|
||||
DoublyListNode *node;
|
||||
|
|
@ -1840,6 +1840,7 @@ comments: true
|
|||
node = node->next;
|
||||
}
|
||||
printArray(arr, deque->queSize);
|
||||
free(arr);
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -2927,44 +2928,44 @@ comments: true
|
|||
}
|
||||
|
||||
/* 队首入队 */
|
||||
void pushFirst(int num) {
|
||||
void pushFirst(int _num) {
|
||||
if (_queSize == capacity()) {
|
||||
throw Exception("双向队列已满");
|
||||
}
|
||||
// 队首指针向左移动一位
|
||||
// 通过取余操作，实现 _front 越过数组头部后回到尾部
|
||||
_front = index(_front - 1);
|
||||
// 将 num 添加至队首
|
||||
_nums[_front] = num;
|
||||
// 将 _num 添加至队首
|
||||
_nums[_front] = _num;
|
||||
_queSize++;
|
||||
}
|
||||
|
||||
/* 队尾入队 */
|
||||
void pushLast(int num) {
|
||||
void pushLast(int _num) {
|
||||
if (_queSize == capacity()) {
|
||||
throw Exception("双向队列已满");
|
||||
}
|
||||
// 计算尾指针，指向队尾索引 + 1
|
||||
int rear = index(_front + _queSize);
|
||||
// 将 num 添加至队尾
|
||||
_nums[rear] = num;
|
||||
// 将 _num 添加至队尾
|
||||
_nums[rear] = _num;
|
||||
_queSize++;
|
||||
}
|
||||
|
||||
/* 队首出队 */
|
||||
int popFirst() {
|
||||
int num = peekFirst();
|
||||
int _num = peekFirst();
|
||||
// 队首指针向右移动一位
|
||||
_front = index(_front + 1);
|
||||
_queSize--;
|
||||
return num;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* 队尾出队 */
|
||||
int popLast() {
|
||||
int num = peekLast();
|
||||
int _num = peekLast();
|
||||
_queSize--;
|
||||
return num;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* 访问队首元素 */
|
||||
|
|
@ -3218,16 +3219,6 @@ comments: true
|
|||
deque->queSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* 打印队列 */
|
||||
void printArrayDeque(ArrayDeque *deque) {
|
||||
int arr[deque->queSize];
|
||||
// 拷贝
|
||||
for (int i = 0, j = deque->front; i < deque->queSize; i++, j++) {
|
||||
arr[i] = deque->nums[j % deque->queCapacity];
|
||||
}
|
||||
printArray(arr, deque->queSize);
|
||||
}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
|
|
|||
|
|
@ -900,9 +900,9 @@ comments: true
|
|||
}
|
||||
|
||||
/* 入队 */
|
||||
void push(int num) {
|
||||
// 尾节点后添加 num
|
||||
final node = ListNode(num);
|
||||
void push(int _num) {
|
||||
// 尾节点后添加 _num
|
||||
final node = ListNode(_num);
|
||||
// 如果队列为空，则令头、尾节点都指向该节点
|
||||
if (_front == null) {
|
||||
_front = node;
|
||||
|
|
@ -917,11 +917,11 @@ comments: true
|
|||
|
||||
/* 出队 */
|
||||
int pop() {
|
||||
final int num = peek();
|
||||
final int _num = peek();
|
||||
// 删除头节点
|
||||
_front = _front!.next;
|
||||
_queSize--;
|
||||
return num;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* 访问队首元素 */
|
||||
|
|
@ -1101,7 +1101,7 @@ comments: true
|
|||
|
||||
/* 打印队列 */
|
||||
void printLinkedListQueue(LinkedListQueue *queue) {
|
||||
int arr[queue->queSize];
|
||||
int *arr = malloc(sizeof(int) * queue->queSize);
|
||||
// 拷贝链表中的数据到数组
|
||||
int i;
|
||||
ListNode *node;
|
||||
|
|
@ -1110,6 +1110,7 @@ comments: true
|
|||
node = node->next;
|
||||
}
|
||||
printArray(arr, queue->queSize);
|
||||
free(arr);
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -1825,25 +1826,25 @@ comments: true
|
|||
}
|
||||
|
||||
/* 入队 */
|
||||
void push(int num) {
|
||||
void push(int _num) {
|
||||
if (_queSize == capaCity()) {
|
||||
throw Exception("队列已满");
|
||||
}
|
||||
// 计算尾指针，指向队尾索引 + 1
|
||||
// 通过取余操作，实现 rear 越过数组尾部后回到头部
|
||||
int rear = (_front + _queSize) % capaCity();
|
||||
// 将 num 添加至队尾
|
||||
_nums[rear] = num;
|
||||
// 将 _num 添加至队尾
|
||||
_nums[rear] = _num;
|
||||
_queSize++;
|
||||
}
|
||||
|
||||
/* 出队 */
|
||||
int pop() {
|
||||
int num = peek();
|
||||
int _num = peek();
|
||||
// 队首指针向后移动一位，若越过尾部则返回到数组头部
|
||||
_front = (_front + 1) % capaCity();
|
||||
_queSize--;
|
||||
return num;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* 访问队首元素 */
|
||||
|
|
@ -2017,16 +2018,6 @@ comments: true
|
|||
queue->front = (queue->front + 1) % queue->queCapacity;
|
||||
queue->queSize--;
|
||||
}
|
||||
|
||||
/* 打印队列 */
|
||||
void printArrayQueue(ArrayQueue *queue) {
|
||||
int arr[queue->queSize];
|
||||
// 拷贝
|
||||
for (int i = 0, j = queue->front; i < queue->queSize; i++, j++) {
|
||||
arr[i] = queue->nums[j % queue->queCapacity];
|
||||
}
|
||||
printArray(arr, queue->queSize);
|
||||
}
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
|
|
|||
|
|
@ -827,8 +827,8 @@ comments: true
|
|||
}
|
||||
|
||||
/* 入栈 */
|
||||
void push(int num) {
|
||||
final ListNode node = ListNode(num);
|
||||
void push(int _num) {
|
||||
final ListNode node = ListNode(_num);
|
||||
node.next = _stackPeek;
|
||||
_stackPeek = node;
|
||||
_stkSize++;
|
||||
|
|
@ -836,10 +836,10 @@ comments: true
|
|||
|
||||
/* 出栈 */
|
||||
int pop() {
|
||||
final int num = peek();
|
||||
final int _num = peek();
|
||||
_stackPeek = _stackPeek!.next;
|
||||
_stkSize--;
|
||||
return num;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
|
|
@ -1495,8 +1495,8 @@ comments: true
|
|||
}
|
||||
|
||||
/* 入栈 */
|
||||
void push(int num) {
|
||||
_stack.add(num);
|
||||
void push(int _num) {
|
||||
_stack.add(_num);
|
||||
}
|
||||
|
||||
/* 出栈 */
|
||||
|
|
|
|||
|
|
@ -224,15 +224,15 @@ comments: true
|
|||
|
||||
```dart title="binary_search_tree.dart"
|
||||
/* 查找节点 */
|
||||
TreeNode? search(int num) {
|
||||
TreeNode? search(int _num) {
|
||||
TreeNode? cur = _root;
|
||||
// 循环查找，越过叶节点后跳出
|
||||
while (cur != null) {
|
||||
// 目标节点在 cur 的右子树中
|
||||
if (cur.val < num)
|
||||
if (cur.val < _num)
|
||||
cur = cur.right;
|
||||
// 目标节点在 cur 的左子树中
|
||||
else if (cur.val > num)
|
||||
else if (cur.val > _num)
|
||||
cur = cur.left;
|
||||
// 找到目标节点，跳出循环
|
||||
else
|
||||
|
|
@ -601,10 +601,10 @@ comments: true
|
|||
|
||||
```dart title="binary_search_tree.dart"
|
||||
/* 插入节点 */
|
||||
void insert(int num) {
|
||||
void insert(int _num) {
|
||||
// 若树为空，则初始化根节点
|
||||
if (_root == null) {
|
||||
_root = TreeNode(num);
|
||||
_root = TreeNode(_num);
|
||||
return;
|
||||
}
|
||||
TreeNode? cur = _root;
|
||||
|
|
@ -612,18 +612,18 @@ comments: true
|
|||
// 循环查找，越过叶节点后跳出
|
||||
while (cur != null) {
|
||||
// 找到重复节点，直接返回
|
||||
if (cur.val == num) return;
|
||||
if (cur.val == _num) return;
|
||||
pre = cur;
|
||||
// 插入位置在 cur 的右子树中
|
||||
if (cur.val < num)
|
||||
if (cur.val < _num)
|
||||
cur = cur.right;
|
||||
// 插入位置在 cur 的左子树中
|
||||
else
|
||||
cur = cur.left;
|
||||
}
|
||||
// 插入节点
|
||||
TreeNode? node = TreeNode(num);
|
||||
if (pre!.val < num)
|
||||
TreeNode? node = TreeNode(_num);
|
||||
if (pre!.val < _num)
|
||||
pre.right = node;
|
||||
else
|
||||
pre.left = node;
|
||||
|
|
@ -1234,7 +1234,7 @@ comments: true
|
|||
|
||||
```dart title="binary_search_tree.dart"
|
||||
/* 删除节点 */
|
||||
void remove(int num) {
|
||||
void remove(int _num) {
|
||||
// 若树为空，直接提前返回
|
||||
if (_root == null) return;
|
||||
TreeNode? cur = _root;
|
||||
|
|
@ -1242,10 +1242,10 @@ comments: true
|
|||
// 循环查找，越过叶节点后跳出
|
||||
while (cur != null) {
|
||||
// 找到待删除节点，跳出循环
|
||||
if (cur.val == num) break;
|
||||
if (cur.val == _num) break;
|
||||
pre = cur;
|
||||
// 待删除节点在 cur 的右子树中
|
||||
if (cur.val < num)
|
||||
if (cur.val < _num)
|
||||
cur = cur.right;
|
||||
// 待删除节点在 cur 的左子树中
|
||||
else
|
||||
|
|
|
|||
Loading…
Reference in a new issue