github/hello-algo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug fixes

Browse Source
This commit is contained in:
krahets 2024-05-06 03:56:37 +08:00
parent 7c3641c981
commit e2d6dc2368
16 changed files with 28 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
codes/c/chapter_hashing/simple_hash.c
View File

@ -50,7 +50,7 @@ int rotHash(char *key) {
/* Driver Code */ /* Driver Code */
int main() { int main() {
char *key = "Hello dsad3241241dsa算123法"; char *key = "Hello 算法";
int hash = addHash(key); int hash = addHash(key);
printf("加法哈希值为 %d\n", hash); printf("加法哈希值为 %d\n", hash);

2
codes/cpp/chapter_hashing/simple_hash.cpp
View File

@ -48,7 +48,7 @@ int rotHash(string key) {
/* Driver Code */ /* Driver Code */
int main() { int main() {
string key = "Hello dsad3241241dsa算123法"; string key = "Hello 算法";
int hash = addHash(key); int hash = addHash(key);
cout << "加法哈希值为 " << hash << endl; cout << "加法哈希值为 " << hash << endl;

4
codes/javascript/chapter_dynamic_programming/coin_change.js
View File

@ -31,7 +31,7 @@ function coinChangeDP(coins, amt) {
return dp[n][amt] !== MAX ? dp[n][amt] : -1; return dp[n][amt] !== MAX ? dp[n][amt] : -1;
} }
/* 零钱兑换：状态压缩后的动态规划 */ /* 零钱兑换：空间优化后的动态规划 */
function coinChangeDPComp(coins, amt) { function coinChangeDPComp(coins, amt) {
const n = coins.length; const n = coins.length;
const MAX = amt + 1; const MAX = amt + 1;
@ -61,6 +61,6 @@ const amt = 4;
let res = coinChangeDP(coins, amt); let res = coinChangeDP(coins, amt);
console.log(`凑到目标金额所需的最少硬币数量为 ${res}`); console.log(`凑到目标金额所需的最少硬币数量为 ${res}`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = coinChangeDPComp(coins, amt); res = coinChangeDPComp(coins, amt);
console.log(`凑到目标金额所需的最少硬币数量为 ${res}`); console.log(`凑到目标金额所需的最少硬币数量为 ${res}`);

4
codes/javascript/chapter_dynamic_programming/coin_change_ii.js
View File

@ -30,7 +30,7 @@ function coinChangeIIDP(coins, amt) {
return dp[n][amt]; return dp[n][amt];
} }
/* 零钱兑换 II：状态压缩后的动态规划 */ /* 零钱兑换 II：空间优化后的动态规划 */
function coinChangeIIDPComp(coins, amt) { function coinChangeIIDPComp(coins, amt) {
const n = coins.length; const n = coins.length;
// 初始化 dp 表 // 初始化 dp 表
@ -59,6 +59,6 @@ const amt = 5;
let res = coinChangeIIDP(coins, amt); let res = coinChangeIIDP(coins, amt);
console.log(`凑出目标金额的硬币组合数量为 ${res}`); console.log(`凑出目标金额的硬币组合数量为 ${res}`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = coinChangeIIDPComp(coins, amt); res = coinChangeIIDPComp(coins, amt);
console.log(`凑出目标金额的硬币组合数量为 ${res}`); console.log(`凑出目标金额的硬币组合数量为 ${res}`);

4
codes/javascript/chapter_dynamic_programming/edit_distance.js
View File

@ -82,7 +82,7 @@ function editDistanceDP(s, t) {
return dp[n][m]; return dp[n][m];
} }
/* 编辑距离：状态压缩后的动态规划 */ /* 编辑距离：空间优化后的动态规划 */
function editDistanceDPComp(s, t) { function editDistanceDPComp(s, t) {
const n = s.length, const n = s.length,
m = t.length; m = t.length;
@ -130,6 +130,6 @@ console.log(`将 ${s} 更改为 ${t} 最少需要编辑 ${res} 步`);
res = editDistanceDP(s, t); res = editDistanceDP(s, t);
console.log(`将 ${s} 更改为 ${t} 最少需要编辑 ${res} 步`); console.log(`将 ${s} 更改为 ${t} 最少需要编辑 ${res} 步`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = editDistanceDPComp(s, t); res = editDistanceDPComp(s, t);
console.log(`将 ${s} 更改为 ${t} 最少需要编辑 ${res} 步`); console.log(`将 ${s} 更改为 ${t} 最少需要编辑 ${res} 步`);

4
codes/javascript/chapter_dynamic_programming/knapsack.js
View File

@ -69,7 +69,7 @@ function knapsackDP(wgt, val, cap) {
return dp[n][cap]; return dp[n][cap];
} }
/* 0-1 背包：状态压缩后的动态规划 */ /* 0-1 背包：空间优化后的动态规划 */
function knapsackDPComp(wgt, val, cap) { function knapsackDPComp(wgt, val, cap) {
const n = wgt.length; const n = wgt.length;
// 初始化 dp 表 // 初始化 dp 表
@ -108,6 +108,6 @@ console.log(`不超过背包容量的最大物品价值为 ${res}`);
res = knapsackDP(wgt, val, cap); res = knapsackDP(wgt, val, cap);
console.log(`不超过背包容量的最大物品价值为 ${res}`); console.log(`不超过背包容量的最大物品价值为 ${res}`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = knapsackDPComp(wgt, val, cap); res = knapsackDPComp(wgt, val, cap);
console.log(`不超过背包容量的最大物品价值为 ${res}`); console.log(`不超过背包容量的最大物品价值为 ${res}`);

2
codes/javascript/chapter_dynamic_programming/min_cost_climbing_stairs_dp.js
View File

@ -22,7 +22,7 @@ function minCostClimbingStairsDP(cost) {
return dp[n]; return dp[n];
} }
/* 爬楼梯最小代价：状态压缩后的动态规划 */ /* 爬楼梯最小代价：空间优化后的动态规划 */
function minCostClimbingStairsDPComp(cost) { function minCostClimbingStairsDPComp(cost) {
const n = cost.length - 1; const n = cost.length - 1;
if (n === 1 || n === 2) { if (n === 1 || n === 2) {

4
codes/javascript/chapter_dynamic_programming/min_path_sum.js
View File

@ -69,7 +69,7 @@ function minPathSumDP(grid) {
return dp[n - 1][m - 1]; return dp[n - 1][m - 1];
} }
/* 最小路径和：状态压缩后的动态规划 */ /* 最小路径和：空间优化后的动态规划 */
function minPathSumDPComp(grid) { function minPathSumDPComp(grid) {
const n = grid.length, const n = grid.length,
m = grid[0].length; m = grid[0].length;
@ -116,6 +116,6 @@ console.log(`从左上角到右下角的最小路径和为 ${res}`);
res = minPathSumDP(grid); res = minPathSumDP(grid);
console.log(`从左上角到右下角的最小路径和为 ${res}`); console.log(`从左上角到右下角的最小路径和为 ${res}`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = minPathSumDPComp(grid); res = minPathSumDPComp(grid);
console.log(`从左上角到右下角的最小路径和为 ${res}`); console.log(`从左上角到右下角的最小路径和为 ${res}`);

4
codes/javascript/chapter_dynamic_programming/unbounded_knapsack.js
View File

@ -29,7 +29,7 @@ function unboundedKnapsackDP(wgt, val, cap) {
return dp[n][cap]; return dp[n][cap];
} }
/* 完全背包：状态压缩后的动态规划 */ /* 完全背包：空间优化后的动态规划 */
function unboundedKnapsackDPComp(wgt, val, cap) { function unboundedKnapsackDPComp(wgt, val, cap) {
const n = wgt.length; const n = wgt.length;
// 初始化 dp 表 // 初始化 dp 表
@ -58,6 +58,6 @@ const cap = 4;
let res = unboundedKnapsackDP(wgt, val, cap); let res = unboundedKnapsackDP(wgt, val, cap);
console.log(`不超过背包容量的最大物品价值为 ${res}`); console.log(`不超过背包容量的最大物品价值为 ${res}`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = unboundedKnapsackDPComp(wgt, val, cap); res = unboundedKnapsackDPComp(wgt, val, cap);
console.log(`不超过背包容量的最大物品价值为 ${res}`); console.log(`不超过背包容量的最大物品价值为 ${res}`);

4
codes/typescript/chapter_dynamic_programming/coin_change.ts
View File

@ -31,7 +31,7 @@ function coinChangeDP(coins: Array<number>, amt: number): number {
return dp[n][amt] !== MAX ? dp[n][amt] : -1; return dp[n][amt] !== MAX ? dp[n][amt] : -1;
} }
/* 零钱兑换：状态压缩后的动态规划 */ /* 零钱兑换：空间优化后的动态规划 */
function coinChangeDPComp(coins: Array<number>, amt: number): number { function coinChangeDPComp(coins: Array<number>, amt: number): number {
const n = coins.length; const n = coins.length;
const MAX = amt + 1; const MAX = amt + 1;
@ -61,7 +61,7 @@ const amt = 4;
let res = coinChangeDP(coins, amt); let res = coinChangeDP(coins, amt);
console.log(`凑到目标金额所需的最少硬币数量为 ${res}`); console.log(`凑到目标金额所需的最少硬币数量为 ${res}`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = coinChangeDPComp(coins, amt); res = coinChangeDPComp(coins, amt);
console.log(`凑到目标金额所需的最少硬币数量为 ${res}`); console.log(`凑到目标金额所需的最少硬币数量为 ${res}`);

4
codes/typescript/chapter_dynamic_programming/coin_change_ii.ts
View File

@ -30,7 +30,7 @@ function coinChangeIIDP(coins: Array<number>, amt: number): number {
return dp[n][amt]; return dp[n][amt];
} }
/* 零钱兑换 II：状态压缩后的动态规划 */ /* 零钱兑换 II：空间优化后的动态规划 */
function coinChangeIIDPComp(coins: Array<number>, amt: number): number { function coinChangeIIDPComp(coins: Array<number>, amt: number): number {
const n = coins.length; const n = coins.length;
// 初始化 dp 表 // 初始化 dp 表
@ -59,7 +59,7 @@ const amt = 5;
let res = coinChangeIIDP(coins, amt); let res = coinChangeIIDP(coins, amt);
console.log(`凑出目标金额的硬币组合数量为 ${res}`); console.log(`凑出目标金额的硬币组合数量为 ${res}`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = coinChangeIIDPComp(coins, amt); res = coinChangeIIDPComp(coins, amt);
console.log(`凑出目标金额的硬币组合数量为 ${res}`); console.log(`凑出目标金额的硬币组合数量为 ${res}`);

4
codes/typescript/chapter_dynamic_programming/edit_distance.ts
View File

@ -90,7 +90,7 @@ function editDistanceDP(s: string, t: string): number {
return dp[n][m]; return dp[n][m];
} }
/* 编辑距离：状态压缩后的动态规划 */ /* 编辑距离：空间优化后的动态规划 */
function editDistanceDPComp(s: string, t: string): number { function editDistanceDPComp(s: string, t: string): number {
const n = s.length, const n = s.length,
m = t.length; m = t.length;
@ -141,7 +141,7 @@ console.log(`将 ${s} 更改为 ${t} 最少需要编辑 ${res} 步`);
res = editDistanceDP(s, t); res = editDistanceDP(s, t);
console.log(`将 ${s} 更改为 ${t} 最少需要编辑 ${res} 步`); console.log(`将 ${s} 更改为 ${t} 最少需要编辑 ${res} 步`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = editDistanceDPComp(s, t); res = editDistanceDPComp(s, t);
console.log(`将 ${s} 更改为 ${t} 最少需要编辑 ${res} 步`); console.log(`将 ${s} 更改为 ${t} 最少需要编辑 ${res} 步`);

4
codes/typescript/chapter_dynamic_programming/knapsack.ts
View File

@ -84,7 +84,7 @@ function knapsackDP(
return dp[n][cap]; return dp[n][cap];
} }
/* 0-1 背包：状态压缩后的动态规划 */ /* 0-1 背包：空间优化后的动态规划 */
function knapsackDPComp( function knapsackDPComp(
wgt: Array<number>, wgt: Array<number>,
val: Array<number>, val: Array<number>,
@ -127,7 +127,7 @@ console.log(`不超过背包容量的最大物品价值为 ${res}`);
res = knapsackDP(wgt, val, cap); res = knapsackDP(wgt, val, cap);
console.log(`不超过背包容量的最大物品价值为 ${res}`); console.log(`不超过背包容量的最大物品价值为 ${res}`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = knapsackDPComp(wgt, val, cap); res = knapsackDPComp(wgt, val, cap);
console.log(`不超过背包容量的最大物品价值为 ${res}`); console.log(`不超过背包容量的最大物品价值为 ${res}`);

2
codes/typescript/chapter_dynamic_programming/min_cost_climbing_stairs_dp.ts
View File

@ -22,7 +22,7 @@ function minCostClimbingStairsDP(cost: Array<number>): number {
return dp[n]; return dp[n];
} }
/* 爬楼梯最小代价：状态压缩后的动态规划 */ /* 爬楼梯最小代价：空间优化后的动态规划 */
function minCostClimbingStairsDPComp(cost: Array<number>): number { function minCostClimbingStairsDPComp(cost: Array<number>): number {
const n = cost.length - 1; const n = cost.length - 1;
if (n === 1 || n === 2) { if (n === 1 || n === 2) {

4
codes/typescript/chapter_dynamic_programming/min_path_sum.ts
View File

@ -78,7 +78,7 @@ function minPathSumDP(grid: Array<Array<number>>): number {
return dp[n - 1][m - 1]; return dp[n - 1][m - 1];
} }
/* 最小路径和：状态压缩后的动态规划 */ /* 最小路径和：空间优化后的动态规划 */
function minPathSumDPComp(grid: Array<Array<number>>): number { function minPathSumDPComp(grid: Array<Array<number>>): number {
const n = grid.length, const n = grid.length,
m = grid[0].length; m = grid[0].length;
@ -125,7 +125,7 @@ console.log(`从左上角到右下角的最小路径和为 ${res}`);
res = minPathSumDP(grid); res = minPathSumDP(grid);
console.log(`从左上角到右下角的最小路径和为 ${res}`); console.log(`从左上角到右下角的最小路径和为 ${res}`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = minPathSumDPComp(grid); res = minPathSumDPComp(grid);
console.log(`从左上角到右下角的最小路径和为 ${res}`); console.log(`从左上角到右下角的最小路径和为 ${res}`);

4
codes/typescript/chapter_dynamic_programming/unbounded_knapsack.ts
View File

@ -33,7 +33,7 @@ function unboundedKnapsackDP(
return dp[n][cap]; return dp[n][cap];
} }
/* 完全背包：状态压缩后的动态规划 */ /* 完全背包：空间优化后的动态规划 */
function unboundedKnapsackDPComp( function unboundedKnapsackDPComp(
wgt: Array<number>, wgt: Array<number>,
val: Array<number>, val: Array<number>,
@ -66,7 +66,7 @@ const cap = 4;
let res = unboundedKnapsackDP(wgt, val, cap); let res = unboundedKnapsackDP(wgt, val, cap);
console.log(`不超过背包容量的最大物品价值为 ${res}`); console.log(`不超过背包容量的最大物品价值为 ${res}`);
// 状态压缩后的动态规划 // 空间优化后的动态规划
res = unboundedKnapsackDPComp(wgt, val, cap); res = unboundedKnapsackDPComp(wgt, val, cap);
console.log(`不超过背包容量的最大物品价值为 ${res}`); console.log(`不超过背包容量的最大物品价值为 ${res}`);