feat: Add Dart codes for chapter_dynamic_programming and chapter_greedy (#683)

* feat: Add Dart codes for chapter_dynamic_programming

* feat: Add Dart codes for chapter_greedy

codes/dart/chapter_dynamic_programming/climbing_stairs_backtrack.dart

@@ -0,0 +1,39 @@
+/**
+ * File: climbing_stairs_backtrack.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* 回溯 */
+void backtrack(List<int> choices, int state, int n, List<int> res) {
+  // 当爬到第 n 阶时，方案数量加 1
+  if (state == n) {
+    res[0]++;
+  }
+  // 遍历所有选择
+  for (int choice in choices) {
+    // 剪枝：不允许越过第 n 阶
+    if (state + choice > n) break;
+    // 尝试：做出选择，更新状态
+    backtrack(choices, state + choice, n, res);
+    // 回退
+  }
+}
+
+/* 爬楼梯：回溯 */
+int climbingStairsBacktrack(int n) {
+  List<int> choices = [1, 2]; // 可选择向上爬 1 或 2 阶
+  int state = 0; // 从第 0 阶开始爬
+  List<int> res = [];
+  res.add(0); // 使用 res[0] 记录方案数量
+  backtrack(choices, state, n, res);
+  return res[0];
+}
+
+/* Driver Code */
+void main() {
+  int n = 9;
+
+  int res = climbingStairsBacktrack(n);
+  print("爬 $n 阶楼梯共有 $res 种方案");
+}

codes/dart/chapter_dynamic_programming/climbing_stairs_constraint_dp.dart

@@ -0,0 +1,33 @@
+/**
+ * File: climbing_stairs_constraint_dp.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* 带约束爬楼梯：动态规划 */
+int climbingStairsConstraintDP(int n) {
+  if (n == 1 || n == 2) {
+    return n;
+  }
+  // 初始化 dp 表，用于存储子问题的解
+  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(3, 0));
+  // 初始状态：预设最小子问题的解
+  dp[1][1] = 1;
+  dp[1][2] = 0;
+  dp[2][1] = 0;
+  dp[2][2] = 1;
+  // 状态转移：从较小子问题逐步求解较大子问题
+  for (int i = 3; i <= n; i++) {
+    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];
+}
+
+/* Driver Code */
+void main() {
+  int n = 9;
+
+  int res = climbingStairsConstraintDP(n);
+  print("爬 $n 阶楼梯共有 $res 种方案");
+}

codes/dart/chapter_dynamic_programming/climbing_stairs_dfs.dart

@@ -0,0 +1,27 @@
+/**
+ * File: climbing_stairs_dfs.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* 搜索 */
+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;
+}
+
+/* 爬楼梯：搜索 */
+int climbingStairsDFS(int n) {
+  return dfs(n);
+}
+
+/* Driver Code */
+void main() {
+  int n = 9;
+
+  int res = climbingStairsDFS(n);
+  print("爬 $n 阶楼梯共有 $res 种方案");
+}

codes/dart/chapter_dynamic_programming/climbing_stairs_dfs_mem.dart

@@ -0,0 +1,33 @@
+/**
+ * File: climbing_stairs_dfs_mem.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* 记忆化搜索 */
+int dfs(int i, List<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;
+}
+
+/* 爬楼梯：记忆化搜索 */
+int climbingStairsDFSMem(int n) {
+  // mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
+  List<int> mem = List.filled(n + 1, -1);
+  return dfs(n, mem);
+}
+
+/* Driver Code */
+void main() {
+  int n = 9;
+
+  int res = climbingStairsDFSMem(n);
+  print("爬 $n 阶楼梯共有 $res 种方案");
+}

codes/dart/chapter_dynamic_programming/climbing_stairs_dp.dart

@@ -0,0 +1,43 @@
+/**
+ * File: climbing_stairs_dp.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* 爬楼梯：动态规划 */
+int climbingStairsDP(int n) {
+  if (n == 1 || n == 2) return n;
+  // 初始化 dp 表，用于存储子问题的解
+  List<int> dp = List.filled(n + 1, 0);
+  // 初始状态：预设最小子问题的解
+  dp[1] = 1;
+  dp[2] = 2;
+  // 状态转移：从较小子问题逐步求解较大子问题
+  for (int i = 3; i <= n; i++) {
+    dp[i] = dp[i - 1] + dp[i - 2];
+  }
+  return dp[n];
+}
+
+/* 爬楼梯：状态压缩后的动态规划 */
+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;
+}
+
+/* Driver Code */
+void main() {
+  int n = 9;
+
+  int res = climbingStairsDP(n);
+  print("爬 $n 阶楼梯共有 $res 种方案");
+
+  res = climbingStairsDPComp(n);
+  print("爬 $n 阶楼梯共有 $res 种方案");
+}

codes/dart/chapter_dynamic_programming/coin_change.dart

@@ -0,0 +1,68 @@
+/**
+ * File: coin_change.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* 零钱兑换：动态规划 */
+int coinChangeDP(List<int> coins, int amt) {
+  int n = coins.length;
+  int MAX = amt + 1;
+  // 初始化 dp 表
+  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(amt + 1, 0));
+  // 状态转移：首行首列
+  for (int a = 1; a <= amt; a++) {
+    dp[0][a] = MAX;
+  }
+  // 状态转移：其余行列
+  for (int i = 1; i <= n; i++) {
+    for (int a = 1; a <= amt; a++) {
+      if (coins[i - 1] > a) {
+        // 若超过背包容量，则不选硬币 i
+        dp[i][a] = dp[i - 1][a];
+      } else {
+        // 不选和选硬币 i 这两种方案的较小值
+        dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
+      }
+    }
+  }
+  return dp[n][amt] != MAX ? dp[n][amt] : -1;
+}
+
+/* 零钱兑换：状态压缩后的动态规划 */
+int coinChangeDPComp(List<int> coins, int amt) {
+  int n = coins.length;
+  int MAX = amt + 1;
+  // 初始化 dp 表
+  List<int> dp = List.filled(amt + 1, MAX);
+  dp[0] = 0;
+  // 状态转移
+  for (int i = 1; i <= n; i++) {
+    for (int a = 1; a <= amt; a++) {
+      if (coins[i - 1] > a) {
+        // 若超过背包容量，则不选硬币 i
+        dp[a] = dp[a];
+      } else {
+        // 不选和选硬币 i 这两种方案的较小值
+        dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);
+      }
+    }
+  }
+  return dp[amt] != MAX ? dp[amt] : -1;
+}
+
+/* Driver Code */
+void main() {
+  List<int> coins = [1, 2, 5];
+  int amt = 4;
+
+  // 动态规划
+  int res = coinChangeDP(coins, amt);
+  print("凑到目标金额所需的最少硬币数量为 $res");
+
+  // 状态压缩后的动态规划
+  res = coinChangeDPComp(coins, amt);
+  print("凑到目标金额所需的最少硬币数量为 $res");
+}

codes/dart/chapter_dynamic_programming/coin_change_ii.dart

@@ -0,0 +1,64 @@
+/**
+ * File: coin_change_ii.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* 零钱兑换 II：动态规划 */
+int coinChangeIIDP(List<int> coins, int amt) {
+  int n = coins.length;
+  // 初始化 dp 表
+  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(amt + 1, 0));
+  // 初始化首列
+  for (int i = 0; i <= n; i++) {
+    dp[i][0] = 1;
+  }
+  // 状态转移
+  for (int i = 1; i <= n; i++) {
+    for (int a = 1; a <= amt; a++) {
+      if (coins[i - 1] > a) {
+        // 若超过背包容量，则不选硬币 i
+        dp[i][a] = dp[i - 1][a];
+      } else {
+        // 不选和选硬币 i 这两种方案之和
+        dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
+      }
+    }
+  }
+  return dp[n][amt];
+}
+
+/* 零钱兑换 II：状态压缩后的动态规划 */
+int coinChangeIIDPComp(List<int> coins, int amt) {
+  int n = coins.length;
+  // 初始化 dp 表
+  List<int> dp = List.filled(amt + 1, 0);
+  dp[0] = 1;
+  // 状态转移
+  for (int i = 1; i <= n; i++) {
+    for (int a = 1; a <= amt; a++) {
+      if (coins[i - 1] > a) {
+        // 若超过背包容量，则不选硬币 i
+        dp[a] = dp[a];
+      } else {
+        // 不选和选硬币 i 这两种方案之和
+        dp[a] = dp[a] + dp[a - coins[i - 1]];
+      }
+    }
+  }
+  return dp[amt];
+}
+
+/* Driver Code */
+void main() {
+  List<int> coins = [1, 2, 5];
+  int amt = 5;
+
+  // 动态规划
+  int res = coinChangeIIDP(coins, amt);
+  print("凑出目标金额的硬币组合数量为 $res");
+
+  // 状态压缩后的动态规划
+  res = coinChangeIIDPComp(coins, amt);
+  print("凑出目标金额的硬币组合数量为 $res");
+}

codes/dart/chapter_dynamic_programming/edit_distance.dart

@@ -0,0 +1,125 @@
+/**
+ * File: edit_distance.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* 编辑距离：暴力搜索 */
+int editDistanceDFS(String s, String t, int i, int j) {
+  // 若 s 和 t 都为空，则返回 0
+  if (i == 0 && j == 0) return 0;
+  // 若 s 为空，则返回 t 长度
+  if (i == 0) return j;
+  // 若 t 为空，则返回 s 长度
+  if (j == 0) return i;
+  // 若两字符相等，则直接跳过此两字符
+  if (s[i - 1] == t[j - 1]) return editDistanceDFS(s, t, i - 1, j - 1);
+  // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+  int insert = editDistanceDFS(s, t, i, j - 1);
+  int delete = editDistanceDFS(s, t, i - 1, j);
+  int replace = editDistanceDFS(s, t, i - 1, j - 1);
+  // 返回最少编辑步数
+  return min(min(insert, delete), replace) + 1;
+}
+
+/* 编辑距离：记忆化搜索 */
+int editDistanceDFSMem(String s, String t, List<List<int>> mem, int i, int j) {
+  // 若 s 和 t 都为空，则返回 0
+  if (i == 0 && j == 0) return 0;
+  // 若 s 为空，则返回 t 长度
+  if (i == 0) return j;
+  // 若 t 为空，则返回 s 长度
+  if (j == 0) return i;
+  // 若已有记录，则直接返回之
+  if (mem[i][j] != -1) return mem[i][j];
+  // 若两字符相等，则直接跳过此两字符
+  if (s[i - 1] == t[j - 1]) return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
+  // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+  int insert = editDistanceDFSMem(s, t, mem, i, j - 1);
+  int delete = editDistanceDFSMem(s, t, mem, i - 1, j);
+  int replace = editDistanceDFSMem(s, t, mem, i - 1, j - 1);
+  // 记录并返回最少编辑步数
+  mem[i][j] = min(min(insert, delete), replace) + 1;
+  return mem[i][j];
+}
+
+/* 编辑距离：动态规划 */
+int editDistanceDP(String s, String t) {
+  int n = s.length, m = t.length;
+  List<List<int>> dp = List.generate(n + 1, (_) => List.filled(m + 1, 0));
+  // 状态转移：首行首列
+  for (int i = 1; i <= n; i++) {
+    dp[i][0] = i;
+  }
+  for (int j = 1; j <= m; j++) {
+    dp[0][j] = j;
+  }
+  // 状态转移：其余行列
+  for (int i = 1; i <= n; i++) {
+    for (int j = 1; j <= m; j++) {
+      if (s[i - 1] == t[j - 1]) {
+        // 若两字符相等，则直接跳过此两字符
+        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;
+      }
+    }
+  }
+  return dp[n][m];
+}
+
+/* 编辑距离：状态压缩后的动态规划 */
+int editDistanceDPComp(String s, String t) {
+  int n = s.length, m = t.length;
+  List<int> dp = List.filled(m + 1, 0);
+  // 状态转移：首行
+  for (int j = 1; j <= m; j++) {
+    dp[j] = j;
+  }
+  // 状态转移：其余行
+  for (int i = 1; i <= n; i++) {
+    // 状态转移：首列
+    int leftup = dp[0]; // 暂存 dp[i-1, j-1]
+    dp[0] = i;
+    // 状态转移：其余列
+    for (int j = 1; j <= m; j++) {
+      int temp = dp[j];
+      if (s[i - 1] == t[j - 1]) {
+        // 若两字符相等，则直接跳过此两字符
+        dp[j] = leftup;
+      } else {
+        // 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
+        dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;
+      }
+      leftup = temp; // 更新为下一轮的 dp[i-1, j-1]
+    }
+  }
+  return dp[m];
+}
+
+/* Driver Code */
+void main() {
+  String s = "bag";
+  String t = "pack";
+  int n = s.length, m = t.length;
+
+  // 暴力搜索
+  int res = editDistanceDFS(s, t, n, m);
+  print("将 " + s + " 更改为 " + t + " 最少需要编辑 $res 步");
+
+  // 记忆化搜索
+  List<List<int>> mem = List.generate(n + 1, (_) => List.filled(m + 1, -1));
+  res = editDistanceDFSMem(s, t, mem, n, m);
+  print("将 " + s + " 更改为 " + t + " 最少需要编辑 $res 步");
+
+  // 动态规划
+  res = editDistanceDP(s, t);
+  print("将 " + s + " 更改为 " + t + " 最少需要编辑 $res 步");
+
+  // 状态压缩后的动态规划
+  res = editDistanceDPComp(s, t);
+  print("将 " + s + " 更改为 " + t + " 最少需要编辑 $res 步");
+}

codes/dart/chapter_dynamic_programming/knapsack.dart

@@ -0,0 +1,116 @@
+/**
+ * File: knapsack.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* 0-1 背包：暴力搜索 */
+int knapsackDFS(List<int> wgt, List<int> val, int i, int c) {
+  // 若已选完所有物品或背包无容量，则返回价值 0
+  if (i == 0 || c == 0) {
+    return 0;
+  }
+  // 若超过背包容量，则只能不放入背包
+  if (wgt[i - 1] > c) {
+    return knapsackDFS(wgt, val, i - 1, c);
+  }
+  // 计算不放入和放入物品 i 的最大价值
+  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);
+}
+
+/* 0-1 背包：记忆化搜索 */
+int knapsackDFSMem(
+  List<int> wgt,
+  List<int> val,
+  List<List<int>> mem,
+  int i,
+  int c,
+) {
+  // 若已选完所有物品或背包无容量，则返回价值 0
+  if (i == 0 || c == 0) {
+    return 0;
+  }
+  // 若已有记录，则直接返回
+  if (mem[i][c] != -1) {
+    return mem[i][c];
+  }
+  // 若超过背包容量，则只能不放入背包
+  if (wgt[i - 1] > c) {
+    return knapsackDFSMem(wgt, val, mem, i - 1, c);
+  }
+  // 计算不放入和放入物品 i 的最大价值
+  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);
+  int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
+  // 记录并返回两种方案中价值更大的那一个
+  mem[i][c] = max(no, yes);
+  return mem[i][c];
+}
+
+/* 0-1 背包：动态规划 */
+int knapsackDP(List<int> wgt, List<int> val, int cap) {
+  int n = wgt.length;
+  // 初始化 dp 表
+  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0));
+  // 状态转移
+  for (int i = 1; i <= n; i++) {
+    for (int c = 1; c <= cap; c++) {
+      if (wgt[i - 1] > c) {
+        // 若超过背包容量，则不选物品 i
+        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]);
+      }
+    }
+  }
+  return dp[n][cap];
+}
+
+/* 0-1 背包：状态压缩后的动态规划 */
+int knapsackDPComp(List<int> wgt, List<int> val, int cap) {
+  int n = wgt.length;
+  // 初始化 dp 表
+  List<int> dp = List.filled(cap + 1, 0);
+  // 状态转移
+  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]);
+      }
+    }
+  }
+  return dp[cap];
+}
+
+/* Driver Code */
+void main() {
+  List<int> wgt = [10, 20, 30, 40, 50];
+  List<int> val = [50, 120, 150, 210, 240];
+  int cap = 50;
+  int n = wgt.length;
+
+  // 暴力搜索
+  int res = knapsackDFS(wgt, val, n, cap);
+  print("不超过背包容量的最大物品价值为 $res");
+
+  // 记忆化搜索
+  List<List<int>> mem =
+      List.generate(n + 1, (index) => List.filled(cap + 1, -1));
+  res = knapsackDFSMem(wgt, val, mem, n, cap);
+  print("不超过背包容量的最大物品价值为 $res");
+
+  // 动态规划
+  res = knapsackDP(wgt, val, cap);
+  print("不超过背包容量的最大物品价值为 $res");
+
+  // 状态压缩后的动态规划
+  res = knapsackDPComp(wgt, val, cap);
+  print("不超过背包容量的最大物品价值为 $res");
+}

codes/dart/chapter_dynamic_programming/min_cost_climbing_stairs_dp.dart

@@ -0,0 +1,48 @@
+/**
+ * File: min_cost_climbing_stairs_dp.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* 爬楼梯最小代价：动态规划 */
+int minCostClimbingStairsDP(List<int> cost) {
+  int n = cost.length - 1;
+  if (n == 1 || n == 2) return cost[n];
+  // 初始化 dp 表，用于存储子问题的解
+  List<int> dp = List.filled(n + 1, 0);
+  // 初始状态：预设最小子问题的解
+  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];
+  }
+  return dp[n];
+}
+
+/* 爬楼梯最小代价：状态压缩后的动态规划 */
+int minCostClimbingStairsDPComp(List<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 = min(a, tmp) + cost[i];
+    a = tmp;
+  }
+  return b;
+}
+
+/* Driver Code */
+void main() {
+  List<int> cost = [0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1];
+  print("输入楼梯的代价列表为 $cost");
+
+  int res = minCostClimbingStairsDP(cost);
+  print("爬完楼梯的最低代价为 $res");
+
+  res = minCostClimbingStairsDPComp(cost);
+  print("爬完楼梯的最低代价为 $res");
+}

codes/dart/chapter_dynamic_programming/min_path_sum.dart

@@ -0,0 +1,120 @@
+/**
+ * File: min_path_sum.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* 最小路径和：暴力搜索 */
+int minPathSumDFS(List<List<int>> grid, int i, int j) {
+  // 若为左上角单元格，则终止搜索
+  if (i == 0 && j == 0) {
+    return grid[0][0];
+  }
+  // 若行列索引越界，则返回 +∞ 代价
+  if (i < 0 || j < 0) {
+    // 在 Dart 中，int 类型是固定范围的整数，不存在表示“无穷大”的值
+    return BigInt.from(2).pow(31).toInt();
+  }
+  // 计算从左上角到 (i-1, j) 和 (i, j-1) 的最小路径代价
+  int left = minPathSumDFS(grid, i - 1, j);
+  int up = minPathSumDFS(grid, i, j - 1);
+  // 返回从左上角到 (i, j) 的最小路径代价
+  return min(left, up) + grid[i][j];
+}
+
+/* 最小路径和：记忆化搜索 */
+int minPathSumDFSMem(List<List<int>> grid, List<List<int>> mem, int i, int j) {
+  // 若为左上角单元格，则终止搜索
+  if (i == 0 && j == 0) {
+    return grid[0][0];
+  }
+  // 若行列索引越界，则返回 +∞ 代价
+  if (i < 0 || j < 0) {
+    // 在 Dart 中，int 类型是固定范围的整数，不存在表示“无穷大”的值
+    return BigInt.from(2).pow(31).toInt();
+  }
+  // 若已有记录，则直接返回
+  if (mem[i][j] != -1) {
+    return mem[i][j];
+  }
+  // 左边和上边单元格的最小路径代价
+  int left = minPathSumDFSMem(grid, mem, i - 1, j);
+  int up = minPathSumDFSMem(grid, mem, i, j - 1);
+  // 记录并返回左上角到 (i, j) 的最小路径代价
+  mem[i][j] = min(left, up) + grid[i][j];
+  return mem[i][j];
+}
+
+/* 最小路径和：动态规划 */
+int minPathSumDP(List<List<int>> grid) {
+  int n = grid.length, m = grid[0].length;
+  // 初始化 dp 表
+  List<List<int>> dp = List.generate(n, (i) => List.filled(m, 0));
+  dp[0][0] = grid[0][0];
+  // 状态转移：首行
+  for (int j = 1; j < m; j++) {
+    dp[0][j] = dp[0][j - 1] + grid[0][j];
+  }
+  // 状态转移：首列
+  for (int i = 1; i < n; i++) {
+    dp[i][0] = dp[i - 1][0] + grid[i][0];
+  }
+  // 状态转移：其余行列
+  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];
+    }
+  }
+  return dp[n - 1][m - 1];
+}
+
+/* 最小路径和：状态压缩后的动态规划 */
+int minPathSumDPComp(List<List<int>> grid) {
+  int n = grid.length, m = grid[0].length;
+  // 初始化 dp 表
+  List<int> dp = List.filled(m, 0);
+  dp[0] = grid[0][0];
+  for (int j = 1; j < m; j++) {
+    dp[j] = dp[j - 1] + grid[0][j];
+  }
+  // 状态转移：其余行
+  for (int i = 1; i < n; i++) {
+    // 状态转移：首列
+    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];
+    }
+  }
+  return dp[m - 1];
+}
+
+/* Driver Code */
+void main() {
+  List<List<int>> grid = [
+    [1, 3, 1, 5],
+    [2, 2, 4, 2],
+    [5, 3, 2, 1],
+    [4, 3, 5, 2],
+  ];
+  int n = grid.length, m = grid[0].length;
+
+// 暴力搜索
+  int res = minPathSumDFS(grid, n - 1, m - 1);
+  print("从左上角到右下角的做小路径和为 $res");
+
+// 记忆化搜索
+  List<List<int>> mem = List.generate(n, (i) => List.filled(m, -1));
+  res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
+  print("从左上角到右下角的做小路径和为 $res");
+
+// 动态规划
+  res = minPathSumDP(grid);
+  print("从左上角到右下角的做小路径和为 $res");
+
+// 状态压缩后的动态规划
+  res = minPathSumDPComp(grid);
+  print("从左上角到右下角的做小路径和为 $res");
+}

codes/dart/chapter_dynamic_programming/unbounded_knapsack.dart

@@ -0,0 +1,62 @@
+/**
+ * File: unbounded_knapsack.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* 完全背包：动态规划 */
+int unboundedKnapsackDP(List<int> wgt, List<int> val, int cap) {
+  int n = wgt.length;
+  // 初始化 dp 表
+  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0));
+  // 状态转移
+  for (int i = 1; i <= n; i++) {
+    for (int c = 1; c <= cap; c++) {
+      if (wgt[i - 1] > c) {
+        // 若超过背包容量，则不选物品 i
+        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]);
+      }
+    }
+  }
+  return dp[n][cap];
+}
+
+/* 完全背包：状态压缩后的动态规划 */
+int unboundedKnapsackDPComp(List<int> wgt, List<int> val, int cap) {
+  int n = wgt.length;
+  // 初始化 dp 表
+  List<int> dp = List.filled(cap + 1, 0);
+  // 状态转移
+  for (int i = 1; i <= n; i++) {
+    for (int c = 1; c <= cap; c++) {
+      if (wgt[i - 1] > c) {
+        // 若超过背包容量，则不选物品 i
+        dp[c] = dp[c];
+      } else {
+        // 不选和选物品 i 这两种方案的较大值
+        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+      }
+    }
+  }
+  return dp[cap];
+}
+
+/* Driver Code */
+void main() {
+  List<int> wgt = [1, 2, 3];
+  List<int> val = [5, 11, 15];
+  int cap = 4;
+
+  // 动态规划
+  int res = unboundedKnapsackDP(wgt, val, cap);
+  print("不超过背包容量的最大物品价值为 $res");
+
+  // 状态压缩后的动态规划
+  int resComp = unboundedKnapsackDPComp(wgt, val, cap);
+  print("不超过背包容量的最大物品价值为 $resComp");
+}

codes/dart/chapter_greedy/coin_change_greedy.dart

@@ -0,0 +1,50 @@
+/**
+ * File: coin_change_greedy.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* 零钱兑换：贪心 */
+int coinChangeGreedy(List<int> coins, int amt) {
+  // 假设 coins 列表有序
+  int i = coins.length - 1;
+  int count = 0;
+  // 循环进行贪心选择，直到无剩余金额
+  while (amt > 0) {
+    // 找到小于且最接近剩余金额的硬币
+    while (i > 0 && coins[i] > amt) {
+      i--;
+    }
+    // 选择 coins[i]
+    amt -= coins[i];
+    count++;
+  }
+  // 若未找到可行方案，则返回 -1
+  return amt == 0 ? count : -1;
+}
+
+/* Driver Code */
+void main() {
+  // 贪心：能够保证找到全局最优解
+  List<int> coins = [1, 5, 10, 20, 50, 100];
+  int amt = 186;
+  int res = coinChangeGreedy(coins, amt);
+  print("\ncoins = $coins, amt = $amt");
+  print("凑到 $amt 所需的最少硬币数量为 $res");
+
+  // 贪心：无法保证找到全局最优解
+  coins = [1, 20, 50];
+  amt = 60;
+  res = coinChangeGreedy(coins, amt);
+  print("\ncoins = $coins, amt = $amt");
+  print("凑到 $amt 所需的最少硬币数量为 $res");
+  print("实际上需要的最少数量为 3 ，即 20 + 20 + 20");
+
+  // 贪心：无法保证找到全局最优解
+  coins = [1, 49, 50];
+  amt = 98;
+  res = coinChangeGreedy(coins, amt);
+  print("\ncoins = $coins, amt = $amt");
+  print("凑到 $amt 所需的最少硬币数量为 $res");
+  print("实际上需要的最少数量为 2 ，即 49 + 49");
+}

codes/dart/chapter_greedy/fractional_knapsack.dart

@@ -0,0 +1,47 @@
+/**
+ * File: fractional_knapsack.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* 物品 */
+class Item {
+  int w; // 物品重量
+  int v; // 物品价值
+
+  Item(this.w, this.v);
+}
+
+/* 分数背包：贪心 */
+double fractionalKnapsack(List<int> wgt, List<int> val, int cap) {
+  // 创建物品列表，包含两个属性：重量、价值
+  List<Item> items = List.generate(wgt.length, (i) => Item(wgt[i], val[i]));
+  // 按照单位价值 item.v / item.w 从高到低进行排序
+  items.sort((a, b) => (b.v / b.w).compareTo(a.v / a.w));
+  // 循环贪心选择
+  double res = 0;
+  for (Item item in items) {
+    if (item.w <= cap) {
+      // 若剩余容量充足，则将当前物品整个装进背包
+      res += item.v;
+      cap -= item.w;
+    } else {
+      // 若剩余容量不足，则将当前物品的一部分装进背包
+      res += item.v / item.w * cap;
+      // 已无剩余容量，因此跳出循环
+      break;
+    }
+  }
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> wgt = [10, 20, 30, 40, 50];
+  List<int> val = [50, 120, 150, 210, 240];
+  int cap = 50;
+
+  // 贪心算法
+  double res = fractionalKnapsack(wgt, val, cap);
+  print("不超过背包容量的最大物品价值为 $res");
+}

codes/dart/chapter_greedy/max_capacity.dart

@@ -0,0 +1,37 @@
+/**
+ * File: max_capacity.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* 最大容量：贪心 */
+int maxCapacity(List<int> ht) {
+  // 初始化 i, j 分列数组两端
+  int i = 0, j = ht.length - 1;
+  // 初始最大容量为 0
+  int res = 0;
+  // 循环贪心选择，直至两板相遇
+  while (i < j) {
+    // 更新最大容量
+    int cap = min(ht[i], ht[j]) * (j - i);
+    res = max(res, cap);
+    // 向内移动短板
+    if (ht[i] < ht[j]) {
+      i++;
+    } else {
+      j--;
+    }
+  }
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> ht = [3, 8, 5, 2, 7, 7, 3, 4];
+
+  // 贪心算法
+  int res = maxCapacity(ht);
+  print("最大容量为 $res");
+}

codes/dart/chapter_greedy/max_product_cutting.dart

@@ -0,0 +1,37 @@
+/**
+ * File: max_product_cutting.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* 最大切分乘积：贪心 */
+int maxProductCutting(int n) {
+  // 当 n <= 3 时，必须切分出一个 1
+  if (n <= 3) {
+    return 1 * (n - 1);
+  }
+  // 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+  int a = n ~/ 3;
+  int b = n % 3;
+  if (b == 1) {
+    // 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+    return (pow(3, a - 1) * 2 * 2).toInt();
+  }
+  if (b == 2) {
+    // 当余数为 2 时，不做处理
+    return (pow(3, a) * 2).toInt();
+  }
+  // 当余数为 0 时，不做处理
+  return pow(3, a).toInt();
+}
+
+/* Driver Code */
+void main() {
+  int n = 58;
+
+  // 贪心算法
+  int res = maxProductCutting(n);
+  print("最大切分乘积为 $res");
+}