algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-07-06 14:27:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: add the section of the introduction to dynamic programming (#571)

Browse Source 
* add the section of the introduction to
dynamic programming

* add a code comments.
This commit is contained in:
Yudong Jin
2023-06-30 04:31:43 +08:00
committed by GitHub
parent 4722e7bca7
commit 3f03663d2e
28 changed files with 1268 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
codes/java/chapter_dynamic_programming/climbing_stairs_backtrack.java Normal file
View File

@ -0,0 +1,44 @@
/**
* File: climbing_stairs_backtrack.java
* Created Time: 2023-06-30
* Author: Krahets (krahets@163.com)
*/
package chapter_dynamic_programming;
import java.util.*;
public class climbing_stairs_backtrack {
/* 回溯 */
public static void backtrack(List<Integer> choices, int state, int n, List<Integer> res) {
// 当爬到第 n 阶时，方案数量加 1
if (state == n)
res.set(0, res.get(0) + 1);
// 遍历所有选择
for (Integer choice : choices) {
// 剪枝：不允许越过第 n 阶
if (state + choice > n)
break;
// 尝试：做出选择，更新状态
backtrack(choices, state + choice, n, res);
// 回退
}
}
/* 爬楼梯：回溯 */
public static int climbingStairsBacktrack(int n) {
List<Integer> choices = Arrays.asList(1, 2); // 可选择向上爬 1 或 2 阶
int state = 0; // 从第 0 阶开始爬
List<Integer> res = new ArrayList<>();
res.add(0); // 使用 res[0] 记录方案数量
backtrack(choices, state, n, res);
return res.get(0);
}
public static void main(String[] args) {
int n = 9;
int res = climbingStairsBacktrack(n);
System.out.println(String.format("爬 %d 阶楼梯共有 %d 种方案", n, res));
}
}

31
codes/java/chapter_dynamic_programming/climbing_stairs_dfs.java Normal file
View File

@ -0,0 +1,31 @@
/**
* File: climbing_stairs_dfs.java
* Created Time: 2023-06-30
* Author: Krahets (krahets@163.com)
*/
package chapter_dynamic_programming;
public class climbing_stairs_dfs {
/* 搜索 */
public static int dfs(int i) {
// 已知 dp[1] 和 dp[2] ，返回之
if (i == 1 || i == 2)
return i;
// dp[i] = dp[i-1] + dp[i-2]
int count = dfs(i - 1) + dfs(i - 2);
return count;
}
/* 爬楼梯：搜索 */
public static int climbingStairsDFS(int n) {
return dfs(n);
}
public static void main(String[] args) {
int n = 9;
int res = climbingStairsDFS(n);
System.out.println(String.format("爬 %d 阶楼梯共有 %d 种方案", n, res));
}
}

41
codes/java/chapter_dynamic_programming/climbing_stairs_dfs_mem.java Normal file
View File

@ -0,0 +1,41 @@
/**
* File: climbing_stairs_dfs_mem.java
* Created Time: 2023-06-30
* Author: Krahets (krahets@163.com)
*/
package chapter_dynamic_programming;
import java.util.Arrays;
public class climbing_stairs_dfs_mem {
/* 记忆化搜索 */
public static int dfs(int i, int[] mem) {
// 已知 dp[1] 和 dp[2] ，返回之
if (i == 1 || i == 2)
return i;
// 若存在记录 dp[i] ，则直接返回之
if (mem[i] != -1)
return mem[i];
// dp[i] = dp[i-1] + dp[i-2]
int count = dfs(i - 1, mem) + dfs(i - 2, mem);
// 记录 dp[i]
mem[i] = count;
return count;
}
/* 爬楼梯：记忆化搜索 */
public static int climbingStairsDFSMem(int n) {
// mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
int[] mem = new int[n + 1];
Arrays.fill(mem, -1);
return dfs(n, mem);
}
public static void main(String[] args) {
int n = 9;
int res = climbingStairsDFSMem(n);
System.out.println(String.format("爬 %d 阶楼梯共有 %d 种方案", n, res));
}
}

48
codes/java/chapter_dynamic_programming/climbing_stairs_dp.java Normal file
View File

@ -0,0 +1,48 @@
/**
* File: climbing_stairs_dp.java
* Created Time: 2023-06-30
* Author: Krahets (krahets@163.com)
*/
package chapter_dynamic_programming;
public class climbing_stairs_dp {
/* 爬楼梯：动态规划 */
public static int climbingStairsDP(int n) {
if (n == 1 || n == 2)
return n;
// 初始化 dp 列表，用于存储子问题的解
int[] dp = new int[n + 1];
// 初始状态：预设最小子问题的解
dp[1] = 1;
dp[2] = 2;
// 状态转移：从较小子问题逐步求解较大子问题
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
/* 爬楼梯：状态压缩后的动态规划 */
public static int climbingStairsDPComp(int n) {
if (n == 1 || n == 2)
return n;
int a = 1, b = 2;
for (int i = 3; i <= n; i++) {
int tmp = b;
b = a + b;
a = tmp;
}
return b;
}
public static void main(String[] args) {
int n = 9;
int res = climbingStairsDP(n);
System.out.println(String.format("爬 %d 阶楼梯共有 %d 种方案", n, res));
res = climbingStairsDPComp(n);
System.out.println(String.format("爬 %d 阶楼梯共有 %d 种方案", n, res));
}
}

53
codes/java/chapter_dynamic_programming/min_cost_climbing_stairs_dp.java Normal file
View File

@ -0,0 +1,53 @@
/**
* File: min_cost_climbing_stairs_dp.java
* Created Time: 2023-06-30
* Author: Krahets (krahets@163.com)
*/
package chapter_dynamic_programming;
import java.util.Arrays;
public class min_cost_climbing_stairs_dp {
/* 爬楼梯最小代价：动态规划 */
public static int minCostClimbingStairsDP(int[] cost) {
int n = cost.length - 1;
if (n == 1 || n == 2)
return cost[n];
// 初始化 dp 列表，用于存储子问题的解
int[] dp = new int[n + 1];
// 初始状态：预设最小子问题的解
dp[1] = cost[1];
dp[2] = cost[2];
// 状态转移：从较小子问题逐步求解较大子问题
for (int i = 3; i <= n; i++) {
dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
}
return dp[n];
}
/* 爬楼梯最小代价：状态压缩后的动态规划 */
public static int minCostClimbingStairsDPComp(int[] cost) {
int n = cost.length - 1;
if (n == 1 || n == 2)
return cost[n];
int a = cost[1], b = cost[2];
for (int i = 3; i <= n; i++) {
int tmp = b;
b = Math.min(a, tmp) + cost[i];
a = tmp;
}
return b;
}
public static void main(String[] args) {
int[] cost = { 0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1 };
System.out.println(String.format("输入楼梯的代价列表为 %s", Arrays.toString(cost)));
int res = minCostClimbingStairsDP(cost);
System.out.println(String.format("爬完楼梯的最低代价为 %d", res));
res = minCostClimbingStairsDPComp(cost);
System.out.println(String.format("爬完楼梯的最低代价为 %d", res));
}
}