algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-12-16 03:59:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: Update C code for compatibility with the MSVC compiler (#949)

Browse Source 
* Replace VLA with malloc
Replace VLA with malloc to make C code
compatible with cl compiler on Windows.

* Fix C code for CI compiler.

* Fix C code compability to CI.

* check the trigger
This commit is contained in:
Yudong Jin
2023-11-17 00:29:54 +08:00
committed by GitHub
parent e4aa76ed3e
commit f7c41b6bef
23 changed files with 235 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
codes/c/chapter_dynamic_programming/min_path_sum.c
View File

@@ -6,13 +6,16 @@
#include "../utils/common.h"
// 假设矩阵最大行列数为 100
#define MAX_SIZE 100
/* 求最小值 */
int min(int a, int b) {
int myMin(int a, int b) {
return a < b ? a : b;
}
/* 最小路径和：暴力搜索 */
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];
@@ -22,14 +25,14 @@ int minPathSumDFS(int gridCols, int grid[][gridCols], int i, int j) {
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;
}
/* 最小路径和：记忆化搜索 */
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];
@@ -43,17 +46,20 @@ int minPathSumDFSMem(int gridCols, int grid[][gridCols], int mem[][gridCols], in
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];
}
/* 最小路径和：动态规划 */
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++) {
@@ -66,16 +72,21 @@ int minPathSumDP(int gridCols, int grid[][gridCols], int n, int m) {
// 状态转移：其余行列
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;
}
/* 最小路径和：空间优化后的动态规划 */
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++) {
@@ -87,33 +98,36 @@ int minPathSumDPComp(int gridCols, int grid[][gridCols], int n, int m) {
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;
}
/* Driver Code */
int main() {
int grid[][4] = {{1, 3, 1, 5}, {2, 2, 4, 2}, {5, 3, 2, 1}, {4, 3, 5, 2}};
int n = sizeof(grid) / sizeof(grid[0]), m = sizeof(grid[0]) / sizeof(grid[0][0]);
int grid[MAX_SIZE][MAX_SIZE] = {{1, 3, 1, 5}, {2, 2, 4, 2}, {5, 3, 2, 1}, {4, 3, 5, 2}};
int n = 4, m = 4; // 矩阵容量为 MAX_SIZE * MAX_SIZE ，有效行列数为 n * m
// 暴力搜索
int res = minPathSumDFS(m, grid, n - 1, m - 1);
int res = minPathSumDFS(grid, n - 1, m - 1);
printf("从左上角到右下角的最小路径和为 %d\n", res);
// 记忆化搜索
int mem[n][m];
int mem[MAX_SIZE][MAX_SIZE];
memset(mem, -1, sizeof(mem));
res = minPathSumDFSMem(m, grid, mem, n - 1, m - 1);
res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
printf("从左上角到右下角的最小路径和为 %d\n", res);
// 动态规划
res = minPathSumDP(m, grid, n, m);
res = minPathSumDP(grid, n, m);
printf("从左上角到右下角的最小路径和为 %d\n", res);
// 空间优化后的动态规划
res = minPathSumDPComp(m, grid, n, m);
res = minPathSumDPComp(grid, n, m);
printf("从左上角到右下角的最小路径和为 %d\n", res);
return 0;