跳轉至
紙質書（簡體中文版）已發行，詳情請見這裡

# 14.5 完全背包問題

在本節中，我們先求解另一個常見的背包問題：完全背包，再瞭解它的一種特例：零錢兌換。

## 14.5.1 完全背包問題

Question

給定 \(n\) 個物品，第 \(i\) 個物品的重量為 \(wgt[i-1]\)、價值為 \(val[i-1]\) ，和一個容量為 \(cap\) 的背包。每個物品可以重複選取，問在限定背包容量下能放入物品的最大價值。示例如圖 14-22 所示。

圖 14-22 完全背包問題的示例資料

### 1. 動態規劃思路

完全背包問題和 0-1 背包問題非常相似，區別僅在於不限制物品的選擇次數。

- 在 0-1 背包問題中，每種物品只有一個，因此將物品 \(i\) 放入背包後，只能從前 \(i-1\) 個物品中選擇。
- 在完全背包問題中，每種物品的數量是無限的，因此將物品 \(i\) 放入背包後，仍可以從前 \(i\) 個物品中選擇。

在完全背包問題的規定下，狀態 \([i, c]\) 的變化分為兩種情況。

- 不放入物品 \(i\) ：與 0-1 背包問題相同，轉移至 \([i-1, c]\) 。
- 放入物品 \(i\) ：與 0-1 背包問題不同，轉移至 \([i, c-wgt[i-1]]\) 。

從而狀態轉移方程變為：

\[ dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) \]

### 2. 程式碼實現

對比兩道題目的程式碼，狀態轉移中有一處從 \(i-1\) 變為 \(i\) ，其餘完全一致：

Python C++Java C#Go Swift JS TS Dart Rust C Kotlin Ruby Zig
unbounded_knapsack.py

    def unbounded_knapsack_dp(wgt: list[int], val: list[int], cap: int) -> int:
        """完全背包：動態規劃"""
        n = len(wgt)
        # 初始化 dp 表
        dp = [[0] * (cap + 1) for _ in range(n + 1)]
        # 狀態轉移
        for i in range(1, n + 1):
            for c in range(1, cap + 1):
                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]

unbounded_knapsack.cpp

    /* 完全背包：動態規劃 */
    int unboundedKnapsackDP(vector<int> &wgt, vector<int> &val, int cap) {
        int n = wgt.size();
        // 初始化 dp 表
        vector<vector<int>> dp(n + 1, vector<int>(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];
    }

unbounded_knapsack.java

    /* 完全背包：動態規劃 */
    int unboundedKnapsackDP(int[] wgt, int[] val, int cap) {
        int n = wgt.length;
        // 初始化 dp 表
        int[][] dp = new int[n + 1][cap + 1];
        // 狀態轉移
        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] = Math.max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
                }
            }
        }
        return dp[n][cap];
    }

unbounded_knapsack.cs

    /* 完全背包：動態規劃 */
    int UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {
        int n = wgt.Length;
        // 初始化 dp 表
        int[,] dp = new int[n + 1, cap + 1];
        // 狀態轉移
        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] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);
                }
            }
        }
        return dp[n, cap];
    }

unbounded_knapsack.go

    /* 完全背包：動態規劃 */
    func unboundedKnapsackDP(wgt, val []int, cap int) int {
        n := len(wgt)
        // 初始化 dp 表
        dp := make([][]int, n+1)
        for i := 0; i <= n; i++ {
            dp[i] = make([]int, cap+1)
        }
        // 狀態轉移
        for i := 1; i <= n; i++ {
            for c := 1; c <= cap; c++ {
                if wgt[i-1] > c {
                    // 若超過背包容量，則不選物品 i
                    dp[i][c] = dp[i-1][c]
                } else {
                    // 不選和選物品 i 這兩種方案的較大值
                    dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))
                }
            }
        }
        return dp[n][cap]
    }

unbounded_knapsack.swift

    /* 完全背包：動態規劃 */
    func unboundedKnapsackDP(wgt: [Int], val: [Int], cap: Int) -> Int {
        let n = wgt.count
        // 初始化 dp 表
        var dp = Array(repeating: Array(repeating: 0, count: cap + 1), count: n + 1)
        // 狀態轉移
        for i in 1 ... n {
            for c in 1 ... cap {
                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]
    }

unbounded_knapsack.js

    /* 完全背包：動態規劃 */
    function unboundedKnapsackDP(wgt, val, cap) {
        const n = wgt.length;
        // 初始化 dp 表
        const dp = Array.from({ length: n + 1 }, () =>
            Array.from({ length: cap + 1 }, () => 0)
        );
        // 狀態轉移
        for (let i = 1; i <= n; i++) {
            for (let c = 1; c <= cap; c++) {
                if (wgt[i - 1] > c) {
                    // 若超過背包容量，則不選物品 i
                    dp[i][c] = dp[i - 1][c];
                } else {
                    // 不選和選物品 i 這兩種方案的較大值
                    dp[i][c] = Math.max(
                        dp[i - 1][c],
                        dp[i][c - wgt[i - 1]] + val[i - 1]
                    );
                }
            }
        }
        return dp[n][cap];
    }

unbounded_knapsack.ts

    /* 完全背包：動態規劃 */
    function unboundedKnapsackDP(
        wgt: Array<number>,
        val: Array<number>,
        cap: number
    ): number {
        const n = wgt.length;
        // 初始化 dp 表
        const dp = Array.from({ length: n + 1 }, () =>
            Array.from({ length: cap + 1 }, () => 0)
        );
        // 狀態轉移
        for (let i = 1; i <= n; i++) {
            for (let c = 1; c <= cap; c++) {
                if (wgt[i - 1] > c) {
                    // 若超過背包容量，則不選物品 i
                    dp[i][c] = dp[i - 1][c];
                } else {
                    // 不選和選物品 i 這兩種方案的較大值
                    dp[i][c] = Math.max(
                        dp[i - 1][c],
                        dp[i][c - wgt[i - 1]] + val[i - 1]
                    );
                }
            }
        }
        return dp[n][cap];
    }

unbounded_knapsack.dart

    /* 完全背包：動態規劃 */
    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];
    }

unbounded_knapsack.rs

    /* 完全背包：動態規劃 */
    fn unbounded_knapsack_dp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {
        let n = wgt.len();
        // 初始化 dp 表
        let mut dp = vec![vec![0; cap + 1]; n + 1];
        // 狀態轉移
        for i in 1..=n {
            for c in 1..=cap {
                if wgt[i - 1] > c as i32 {
                    // 若超過背包容量，則不選物品 i
                    dp[i][c] = dp[i - 1][c];
                } else {
                    // 不選和選物品 i 這兩種方案的較大值
                    dp[i][c] = std::cmp::max(dp[i - 1][c], dp[i][c - wgt[i - 1] as usize] + val[i - 1]);
                }
            }
        }
        return dp[n][cap];
    }

unbounded_knapsack.c

    /* 完全背包：動態規劃 */
    int unboundedKnapsackDP(int wgt[], int val[], int cap, int wgtSize) {
        int n = wgtSize;
        // 初始化 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++) {
                if (wgt[i - 1] > c) {
                    // 若超過背包容量，則不選物品 i
                    dp[i][c] = dp[i - 1][c];
                } else {
                    // 不選和選物品 i 這兩種方案的較大值
                    dp[i][c] = myMax(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
                }
            }
        }
        int res = dp[n][cap];
        // 釋放記憶體
        for (int i = 0; i <= n; i++) {
            free(dp[i]);
        }
        return res;
    }

unbounded_knapsack.kt

    /* 完全背包：動態規劃 */
    fun unboundedKnapsackDP(wgt: IntArray, _val: IntArray, cap: Int): Int {
        val n = wgt.size
        // 初始化 dp 表
        val dp = Array(n + 1) { IntArray(cap + 1) }
        // 狀態轉移
        for (i in 1..n) {
            for (c in 1..cap) {
                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]
    }

unbounded_knapsack.rb

    ### 完全背包：動態規劃 ###
    def unbounded_knapsack_dp(wgt, val, cap)
      n = wgt.length
      # 初始化 dp 表
      dp = Array.new(n + 1) { Array.new(cap + 1, 0) }
      # 狀態轉移
      for i in 1...(n + 1)
        for c in 1...(cap + 1)
          if wgt[i - 1] > c
            # 若超過背包容量，則不選物品 i
            dp[i][c] = dp[i - 1][c]
          else
            # 不選和選物品 i 這兩種方案的較大值
            dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max
          end
        end
      end
      dp[n][cap]
    end

unbounded_knapsack.zig

    // 完全背包：動態規劃
    fn unboundedKnapsackDP(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 {
        comptime var n = wgt.len;
        // 初始化 dp 表
        var dp = [_][cap + 1]i32{[_]i32{0} ** (cap + 1)} ** (n + 1);
        // 狀態轉移
        for (1..n + 1) |i| {
            for (1..cap + 1) |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 - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]);
                }
            }
        }
        return dp[n][cap];
    }

視覺化執行

全螢幕觀看 >

### 3. 空間最佳化

由於當前狀態是從左邊和上邊的狀態轉移而來的，因此空間最佳化後應該對 \(dp\) 表中的每一行進行正序走訪。

這個走訪順序與 0-1 背包正好相反。請藉助圖 14-23 來理解兩者的區別。

<1><2><3><4><5><6>

圖 14-23 完全背包問題在空間最佳化後的動態規劃過程

程式碼實現比較簡單，僅需將陣列 `dp` 的第一維刪除：

Python C++Java C#Go Swift JS TS Dart Rust C Kotlin Ruby Zig
unbounded_knapsack.py

    def unbounded_knapsack_dp_comp(wgt: list[int], val: list[int], cap: int) -> int:
        """完全背包：空間最佳化後的動態規劃"""
        n = len(wgt)
        # 初始化 dp 表
        dp = [0] * (cap + 1)
        # 狀態轉移
        for i in range(1, n + 1):
            # 正序走訪
            for c in range(1, cap + 1):
                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]

unbounded_knapsack.cpp

    /* 完全背包：空間最佳化後的動態規劃 */
    int unboundedKnapsackDPComp(vector<int> &wgt, vector<int> &val, int cap) {
        int n = wgt.size();
        // 初始化 dp 表
        vector<int> dp(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];
    }

unbounded_knapsack.java

    /* 完全背包：空間最佳化後的動態規劃 */
    int unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
        int n = wgt.length;
        // 初始化 dp 表
        int[] dp = new int[cap + 1];
        // 狀態轉移
        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] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
                }
            }
        }
        return dp[cap];
    }

unbounded_knapsack.cs

    /* 完全背包：空間最佳化後的動態規劃 */
    int UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
        int n = wgt.Length;
        // 初始化 dp 表
        int[] dp = new int[cap + 1];
        // 狀態轉移
        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] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
                }
            }
        }
        return dp[cap];
    }

unbounded_knapsack.go

    /* 完全背包：空間最佳化後的動態規劃 */
    func unboundedKnapsackDPComp(wgt, val []int, cap int) int {
        n := len(wgt)
        // 初始化 dp 表
        dp := make([]int, cap+1)
        // 狀態轉移
        for i := 1; i <= n; i++ {
            for c := 1; c <= cap; c++ {
                if wgt[i-1] > c {
                    // 若超過背包容量，則不選物品 i
                    dp[c] = dp[c]
                } else {
                    // 不選和選物品 i 這兩種方案的較大值
                    dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))
                }
            }
        }
        return dp[cap]
    }

unbounded_knapsack.swift

    /* 完全背包：空間最佳化後的動態規劃 */
    func unboundedKnapsackDPComp(wgt: [Int], val: [Int], cap: Int) -> Int {
        let n = wgt.count
        // 初始化 dp 表
        var dp = Array(repeating: 0, count: cap + 1)
        // 狀態轉移
        for i in 1 ... n {
            for c in 1 ... cap {
                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]
    }

unbounded_knapsack.js

    /* 完全背包：空間最佳化後的動態規劃 */
    function unboundedKnapsackDPComp(wgt, val, cap) {
        const n = wgt.length;
        // 初始化 dp 表
        const dp = Array.from({ length: cap + 1 }, () => 0);
        // 狀態轉移
        for (let i = 1; i <= n; i++) {
            for (let c = 1; c <= cap; c++) {
                if (wgt[i - 1] > c) {
                    // 若超過背包容量，則不選物品 i
                    dp[c] = dp[c];
                } else {
                    // 不選和選物品 i 這兩種方案的較大值
                    dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
                }
            }
        }
        return dp[cap];
    }

unbounded_knapsack.ts

    /* 完全背包：空間最佳化後的動態規劃 */
    function unboundedKnapsackDPComp(
        wgt: Array<number>,
        val: Array<number>,
        cap: number
    ): number {
        const n = wgt.length;
        // 初始化 dp 表
        const dp = Array.from({ length: cap + 1 }, () => 0);
        // 狀態轉移
        for (let i = 1; i <= n; i++) {
            for (let c = 1; c <= cap; c++) {
                if (wgt[i - 1] > c) {
                    // 若超過背包容量，則不選物品 i
                    dp[c] = dp[c];
                } else {
                    // 不選和選物品 i 這兩種方案的較大值
                    dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
                }
            }
        }
        return dp[cap];
    }

unbounded_knapsack.dart

    /* 完全背包：空間最佳化後的動態規劃 */
    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];
    }

unbounded_knapsack.rs

    /* 完全背包：空間最佳化後的動態規劃 */
    fn unbounded_knapsack_dp_comp(wgt: &[i32], val: &[i32], cap: usize) -> i32 {
        let n = wgt.len();
        // 初始化 dp 表
        let mut dp = vec![0; cap + 1];
        // 狀態轉移
        for i in 1..=n {
            for c in 1..=cap {
                if wgt[i - 1] > c as i32 {
                    // 若超過背包容量，則不選物品 i
                    dp[c] = dp[c];
                } else {
                    // 不選和選物品 i 這兩種方案的較大值
                    dp[c] = std::cmp::max(dp[c], dp[c - wgt[i - 1] as usize] + val[i - 1]);
                }
            }
        }
        dp[cap]
    }

unbounded_knapsack.c

    /* 完全背包：空間最佳化後的動態規劃 */
    int unboundedKnapsackDPComp(int wgt[], int val[], int cap, int wgtSize) {
        int n = wgtSize;
        // 初始化 dp 表
        int *dp = calloc(cap + 1, sizeof(int));
        // 狀態轉移
        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] = myMax(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
                }
            }
        }
        int res = dp[cap];
        // 釋放記憶體
        free(dp);
        return res;
    }

unbounded_knapsack.kt

    /* 完全背包：空間最佳化後的動態規劃 */
    fun unboundedKnapsackDPComp(
        wgt: IntArray,
        _val: IntArray,
        cap: Int
    ): Int {
        val n = wgt.size
        // 初始化 dp 表
        val dp = IntArray(cap + 1)
        // 狀態轉移
        for (i in 1..n) {
            for (c in 1..cap) {
                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]
    }

unbounded_knapsack.rb

    ### 完全背包：動態規劃 ###
    def unbounded_knapsack_dp(wgt, val, cap)
      n = wgt.length
      # 初始化 dp 表
      dp = Array.new(n + 1) { Array.new(cap + 1, 0) }
      # 狀態轉移
      for i in 1...(n + 1)
        for c in 1...(cap + 1)
          if wgt[i - 1] > c
            # 若超過背包容量，則不選物品 i
            dp[i][c] = dp[i - 1][c]
          else
            # 不選和選物品 i 這兩種方案的較大值
            dp[i][c] = [dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]].max
          end
        end
      end
      dp[n][cap]
    end

    ### 完全背包：空間最佳化後的動態規劃 ##3
    def unbounded_knapsack_dp_comp(wgt, val, cap)
      n = wgt.length
      # 初始化 dp 表
      dp = Array.new(cap + 1, 0)
      # 狀態轉移
      for i in 1...(n + 1)
        # 正序走訪
        for c in 1...(cap + 1)
          if wgt[i -1] > c
            # 若超過背包容量，則不選物品 i
            dp[c] = dp[c]
          else
            # 不選和選物品 i 這兩種方案的較大值
            dp[c] = [dp[c], dp[c - wgt[i - 1]] + val[i - 1]].max
          end
        end
      end
      dp[cap]
    end

unbounded_knapsack.zig

    // 完全背包：空間最佳化後的動態規劃
    fn unboundedKnapsackDPComp(comptime wgt: []i32, val: []i32, comptime cap: usize) i32 {
        comptime var n = wgt.len;
        // 初始化 dp 表
        var dp = [_]i32{0} ** (cap + 1);
        // 狀態轉移
        for (1..n + 1) |i| {
            for (1..cap + 1) |c| {
                if (wgt[i - 1] > c) {
                    // 若超過背包容量，則不選物品 i
                    dp[c] = dp[c];
                } else {
                    // 不選和選物品 i 這兩種方案的較大值
                    dp[c] = @max(dp[c], dp[c - @as(usize, @intCast(wgt[i - 1]))] + val[i - 1]);
                }
            }
        }
        return dp[cap];
    }

視覺化執行

全螢幕觀看 >

## 14.5.2 零錢兌換問題

背包問題是一大類動態規劃問題的代表，其擁有很多變種，例如零錢兌換問題。

Question

給定 \(n\) 種硬幣，第 \(i\) 種硬幣的面值為 \(coins[i - 1]\) ，目標金額為 \(amt\) ，每種硬幣可以重複選取，問能夠湊出目標金額的最少硬幣數量。如果無法湊出目標金額，則返回 \(-1\) 。示例如圖 14-24 所示。

圖 14-24 零錢兌換問題的示例資料

### 1. 動態規劃思路

零錢兌換可以看作完全背包問題的一種特殊情況，兩者具有以下關聯與不同點。

- 兩道題可以相互轉換，“物品”對應“硬幣”、“物品重量”對應“硬幣面值”、“背包容量”對應“目標金額”。
- 最佳化目標相反，完全背包問題是要最大化物品價值，零錢兌換問題是要最小化硬幣數量。
- 完全背包問題是求“不超過”背包容量下的解，零錢兌換是求“恰好”湊到目標金額的解。

第一步：思考每輪的決策，定義狀態，從而得到 \(dp\) 表

狀態 \([i, a]\) 對應的子問題為：前 \(i\) 種硬幣能夠湊出金額 \(a\) 的最少硬幣數量，記為 \(dp[i, a]\) 。

二維 \(dp\) 表的尺寸為 \((n+1) \times (amt+1)\) 。

第二步：找出最優子結構，進而推導出狀態轉移方程

本題與完全背包問題的狀態轉移方程存在以下兩點差異。

- 本題要求最小值，因此需將運算子 \(\max()\) 更改為 \(\min()\) 。
- 最佳化主體是硬幣數量而非商品價值，因此在選中硬幣時執行 \(+1\) 即可。

\[ dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) \]

第三步：確定邊界條件和狀態轉移順序

當目標金額為 \(0\) 時，湊出它的最少硬幣數量為 \(0\) ，即首列所有 \(dp[i, 0]\) 都等於 \(0\) 。

當無硬幣時，無法湊出任意 \(> 0\) 的目標金額，即是無效解。為使狀態轉移方程中的 \(\min()\) 函式能夠識別並過濾無效解，我們考慮使用 \(+ \infty\) 來表示它們，即令首行所有 \(dp[0, a]\) 都等於 \(+ \infty\) 。

### 2. 程式碼實現

大多數程式語言並未提供 \(+ \infty\) 變數，只能使用整型 `int` 的最大值來代替。而這又會導致大數越界：狀態轉移方程中的 \(+ 1\) 操作可能發生溢位。

為此，我們採用數字 \(amt + 1\) 來表示無效解，因為湊出 \(amt\) 的硬幣數量最多為 \(amt\) 。最後返回前，判斷 \(dp[n, amt]\) 是否等於 \(amt + 1\) ，若是則返回 \(-1\) ，代表無法湊出目標金額。程式碼如下所示：

Python C++Java C#Go Swift JS TS Dart Rust C Kotlin Ruby Zig
coin_change.py

    def coin_change_dp(coins: list[int], amt: int) -> int:
        """零錢兌換：動態規劃"""
        n = len(coins)
        MAX = amt + 1
        # 初始化 dp 表
        dp = [[0] * (amt + 1) for _ in range(n + 1)]
        # 狀態轉移：首行首列
        for a in range(1, amt + 1):
            dp[0][a] = MAX
        # 狀態轉移：其餘行和列
        for i in range(1, n + 1):
            for a in range(1, amt + 1):
                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] if dp[n][amt] != MAX else -1

coin_change.cpp

    /* 零錢兌換：動態規劃 */
    int coinChangeDP(vector<int> &coins, int amt) {
        int n = coins.size();
        int MAX = amt + 1;
        // 初始化 dp 表
        vector<vector<int>> dp(n + 1, vector<int>(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;
    }

coin_change.java

    /* 零錢兌換：動態規劃 */
    int coinChangeDP(int[] coins, int amt) {
        int n = coins.length;
        int MAX = amt + 1;
        // 初始化 dp 表
        int[][] dp = new int[n + 1][amt + 1];
        // 狀態轉移：首行首列
        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] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
                }
            }
        }
        return dp[n][amt] != MAX ? dp[n][amt] : -1;
    }

coin_change.cs

    /* 零錢兌換：動態規劃 */
    int CoinChangeDP(int[] coins, int amt) {
        int n = coins.Length;
        int MAX = amt + 1;
        // 初始化 dp 表
        int[,] dp = new int[n + 1, amt + 1];
        // 狀態轉移：首行首列
        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] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);
                }
            }
        }
        return dp[n, amt] != MAX ? dp[n, amt] : -1;
    }

coin_change.go

    /* 零錢兌換：動態規劃 */
    func coinChangeDP(coins []int, amt int) int {
        n := len(coins)
        max := amt + 1
        // 初始化 dp 表
        dp := make([][]int, n+1)
        for i := 0; i <= n; i++ {
            dp[i] = make([]int, amt+1)
        }
        // 狀態轉移：首行首列
        for a := 1; a <= amt; a++ {
            dp[0][a] = max
        }
        // 狀態轉移：其餘行和列
        for i := 1; i <= n; i++ {
            for a := 1; a <= amt; a++ {
                if coins[i-1] > a {
                    // 若超過目標金額，則不選硬幣 i
                    dp[i][a] = dp[i-1][a]
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))
                }
            }
        }
        if dp[n][amt] != max {
            return dp[n][amt]
        }
        return -1
    }

coin_change.swift

    /* 零錢兌換：動態規劃 */
    func coinChangeDP(coins: [Int], amt: Int) -> Int {
        let n = coins.count
        let MAX = amt + 1
        // 初始化 dp 表
        var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)
        // 狀態轉移：首行首列
        for a in 1 ... amt {
            dp[0][a] = MAX
        }
        // 狀態轉移：其餘行和列
        for i in 1 ... n {
            for a in 1 ... amt {
                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
    }

coin_change.js

    /* 零錢兌換：動態規劃 */
    function coinChangeDP(coins, amt) {
        const n = coins.length;
        const MAX = amt + 1;
        // 初始化 dp 表
        const dp = Array.from({ length: n + 1 }, () =>
            Array.from({ length: amt + 1 }, () => 0)
        );
        // 狀態轉移：首行首列
        for (let a = 1; a <= amt; a++) {
            dp[0][a] = MAX;
        }
        // 狀態轉移：其餘行和列
        for (let i = 1; i <= n; i++) {
            for (let a = 1; a <= amt; a++) {
                if (coins[i - 1] > a) {
                    // 若超過目標金額，則不選硬幣 i
                    dp[i][a] = dp[i - 1][a];
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
                }
            }
        }
        return dp[n][amt] !== MAX ? dp[n][amt] : -1;
    }

coin_change.ts

    /* 零錢兌換：動態規劃 */
    function coinChangeDP(coins: Array<number>, amt: number): number {
        const n = coins.length;
        const MAX = amt + 1;
        // 初始化 dp 表
        const dp = Array.from({ length: n + 1 }, () =>
            Array.from({ length: amt + 1 }, () => 0)
        );
        // 狀態轉移：首行首列
        for (let a = 1; a <= amt; a++) {
            dp[0][a] = MAX;
        }
        // 狀態轉移：其餘行和列
        for (let i = 1; i <= n; i++) {
            for (let a = 1; a <= amt; a++) {
                if (coins[i - 1] > a) {
                    // 若超過目標金額，則不選硬幣 i
                    dp[i][a] = dp[i - 1][a];
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
                }
            }
        }
        return dp[n][amt] !== MAX ? dp[n][amt] : -1;
    }

coin_change.dart

    /* 零錢兌換：動態規劃 */
    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;
    }

coin_change.rs

    /* 零錢兌換：動態規劃 */
    fn coin_change_dp(coins: &[i32], amt: usize) -> i32 {
        let n = coins.len();
        let max = amt + 1;
        // 初始化 dp 表
        let mut dp = vec![vec![0; amt + 1]; n + 1];
        // 狀態轉移：首行首列
        for a in 1..=amt {
            dp[0][a] = max;
        }
        // 狀態轉移：其餘行和列
        for i in 1..=n {
            for a in 1..=amt {
                if coins[i - 1] > a as i32 {
                    // 若超過目標金額，則不選硬幣 i
                    dp[i][a] = dp[i - 1][a];
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[i][a] = std::cmp::min(dp[i - 1][a], dp[i][a - coins[i - 1] as usize] + 1);
                }
            }
        }
        if dp[n][amt] != max {
            return dp[n][amt] as i32;
        } else {
            -1
        }
    }

coin_change.c

    /* 零錢兌換：動態規劃 */
    int coinChangeDP(int coins[], int amt, int coinsSize) {
        int n = coinsSize;
        int MAX = amt + 1;
        // 初始化 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;
        }
        // 狀態轉移：其餘行和列
        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] = myMin(dp[i - 1][a], dp[i][a - coins[i - 1]] + 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;
    }

coin_change.kt

    /* 零錢兌換：動態規劃 */
    fun coinChangeDP(coins: IntArray, amt: Int): Int {
        val n = coins.size
        val MAX = amt + 1
        // 初始化 dp 表
        val dp = Array(n + 1) { IntArray(amt + 1) }
        // 狀態轉移：首行首列
        for (a in 1..amt) {
            dp[0][a] = MAX
        }
        // 狀態轉移：其餘行和列
        for (i in 1..n) {
            for (a in 1..amt) {
                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 if (dp[n][amt] != MAX) dp[n][amt] else -1
    }

coin_change.rb

    ### 零錢兌換：動態規劃 ###
    def coin_change_dp(coins, amt)
      n = coins.length
      _MAX = amt + 1
      # 初始化 dp 表
      dp = Array.new(n + 1) { Array.new(amt + 1, 0) }
      # 狀態轉移：首行首列
      (1...(amt + 1)).each { |a| dp[0][a] = _MAX }
      # 狀態轉移：其餘行和列
      for i in 1...(n + 1)
        for a in 1...(amt + 1)
          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]] + 1].min
          end
        end
      end
      dp[n][amt] != _MAX ? dp[n][amt] : -1
    end

coin_change.zig

    // 零錢兌換：動態規劃
    fn coinChangeDP(comptime coins: []i32, comptime amt: usize) i32 {
        comptime var n = coins.len;
        comptime var max = amt + 1;
        // 初始化 dp 表
        var dp = [_][amt + 1]i32{[_]i32{0} ** (amt + 1)} ** (n + 1);
        // 狀態轉移：首行首列
        for (1..amt + 1) |a| {
            dp[0][a] = max;
        }
        // 狀態轉移：其餘行和列
        for (1..n + 1) |i| {
            for (1..amt + 1) |a| {
                if (coins[i - 1] > @as(i32, @intCast(a))) {
                    // 若超過目標金額，則不選硬幣 i
                    dp[i][a] = dp[i - 1][a];
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[i][a] = @min(dp[i - 1][a], dp[i][a - @as(usize, @intCast(coins[i - 1]))] + 1);
                }
            }
        }
        if (dp[n][amt] != max) {
            return @intCast(dp[n][amt]);
        } else {
            return -1;
        }
    }

視覺化執行

全螢幕觀看 >

圖 14-25 展示了零錢兌換的動態規劃過程，和完全背包問題非常相似。

<1><2><3><4><5><6><7><8><9><10><11><12><13><14><15>

圖 14-25 零錢兌換問題的動態規劃過程

### 3. 空間最佳化

零錢兌換的空間最佳化的處理方式和完全背包問題一致：

Python C++Java C#Go Swift JS TS Dart Rust C Kotlin Ruby Zig
coin_change.py

    def coin_change_dp_comp(coins: list[int], amt: int) -> int:
        """零錢兌換：空間最佳化後的動態規劃"""
        n = len(coins)
        MAX = amt + 1
        # 初始化 dp 表
        dp = [MAX] * (amt + 1)
        dp[0] = 0
        # 狀態轉移
        for i in range(1, n + 1):
            # 正序走訪
            for a in range(1, amt + 1):
                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] if dp[amt] != MAX else -1

coin_change.cpp

    /* 零錢兌換：空間最佳化後的動態規劃 */
    int coinChangeDPComp(vector<int> &coins, int amt) {
        int n = coins.size();
        int MAX = amt + 1;
        // 初始化 dp 表
        vector<int> dp(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;
    }

coin_change.java

    /* 零錢兌換：空間最佳化後的動態規劃 */
    int coinChangeDPComp(int[] coins, int amt) {
        int n = coins.length;
        int MAX = amt + 1;
        // 初始化 dp 表
        int[] dp = new int[amt + 1];
        Arrays.fill(dp, 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] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);
                }
            }
        }
        return dp[amt] != MAX ? dp[amt] : -1;
    }

coin_change.cs

    /* 零錢兌換：空間最佳化後的動態規劃 */
    int CoinChangeDPComp(int[] coins, int amt) {
        int n = coins.Length;
        int MAX = amt + 1;
        // 初始化 dp 表
        int[] dp = new int[amt + 1];
        Array.Fill(dp, 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] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);
                }
            }
        }
        return dp[amt] != MAX ? dp[amt] : -1;
    }

coin_change.go

    /* 零錢兌換：動態規劃 */
    func coinChangeDPComp(coins []int, amt int) int {
        n := len(coins)
        max := amt + 1
        // 初始化 dp 表
        dp := make([]int, amt+1)
        for i := 1; i <= amt; i++ {
            dp[i] = max
        }
        // 狀態轉移
        for i := 1; i <= n; i++ {
            // 正序走訪
            for a := 1; a <= amt; a++ {
                if coins[i-1] > a {
                    // 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a]
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))
                }
            }
        }
        if dp[amt] != max {
            return dp[amt]
        }
        return -1
    }

coin_change.swift

    /* 零錢兌換：空間最佳化後的動態規劃 */
    func coinChangeDPComp(coins: [Int], amt: Int) -> Int {
        let n = coins.count
        let MAX = amt + 1
        // 初始化 dp 表
        var dp = Array(repeating: MAX, count: amt + 1)
        dp[0] = 0
        // 狀態轉移
        for i in 1 ... n {
            for a in 1 ... amt {
                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
    }

coin_change.js

    /* 零錢兌換：空間最佳化後的動態規劃 */
    function coinChangeDPComp(coins, amt) {
        const n = coins.length;
        const MAX = amt + 1;
        // 初始化 dp 表
        const dp = Array.from({ length: amt + 1 }, () => MAX);
        dp[0] = 0;
        // 狀態轉移
        for (let i = 1; i <= n; i++) {
            for (let a = 1; a <= amt; a++) {
                if (coins[i - 1] > a) {
                    // 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a];
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);
                }
            }
        }
        return dp[amt] !== MAX ? dp[amt] : -1;
    }

coin_change.ts

    /* 零錢兌換：空間最佳化後的動態規劃 */
    function coinChangeDPComp(coins: Array<number>, amt: number): number {
        const n = coins.length;
        const MAX = amt + 1;
        // 初始化 dp 表
        const dp = Array.from({ length: amt + 1 }, () => MAX);
        dp[0] = 0;
        // 狀態轉移
        for (let i = 1; i <= n; i++) {
            for (let a = 1; a <= amt; a++) {
                if (coins[i - 1] > a) {
                    // 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a];
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);
                }
            }
        }
        return dp[amt] !== MAX ? dp[amt] : -1;
    }

coin_change.dart

    /* 零錢兌換：空間最佳化後的動態規劃 */
    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;
    }

coin_change.rs

    /* 零錢兌換：空間最佳化後的動態規劃 */
    fn coin_change_dp_comp(coins: &[i32], amt: usize) -> i32 {
        let n = coins.len();
        let max = amt + 1;
        // 初始化 dp 表
        let mut dp = vec![0; amt + 1];
        dp.fill(max);
        dp[0] = 0;
        // 狀態轉移
        for i in 1..=n {
            for a in 1..=amt {
                if coins[i - 1] > a as i32 {
                    // 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a];
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[a] = std::cmp::min(dp[a], dp[a - coins[i - 1] as usize] + 1);
                }
            }
        }
        if dp[amt] != max {
            return dp[amt] as i32;
        } else {
            -1
        }
    }

coin_change.c

    /* 零錢兌換：空間最佳化後的動態規劃 */
    int coinChangeDPComp(int coins[], int amt, int coinsSize) {
        int n = coinsSize;
        int MAX = amt + 1;
        // 初始化 dp 表
        int *dp = malloc((amt + 1) * sizeof(int));
        for (int j = 1; j <= amt; j++) {
            dp[j] = 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] = myMin(dp[a], dp[a - coins[i - 1]] + 1);
                }
            }
        }
        int res = dp[amt] != MAX ? dp[amt] : -1;
        // 釋放記憶體
        free(dp);
        return res;
    }

coin_change.kt

    /* 零錢兌換：空間最佳化後的動態規劃 */
    fun coinChangeDPComp(coins: IntArray, amt: Int): Int {
        val n = coins.size
        val MAX = amt + 1
        // 初始化 dp 表
        val dp = IntArray(amt + 1)
        dp.fill(MAX)
        dp[0] = 0
        // 狀態轉移
        for (i in 1..n) {
            for (a in 1..amt) {
                if (coins[i - 1] > a) {
                    // 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a]
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1)
                }
            }
        }
        return if (dp[amt] != MAX) dp[amt] else -1
    }

coin_change.rb

    ### 零錢兌換：空間最佳化後的動態規劃 ###
    def coin_change_dp_comp(coins, amt)
      n = coins.length
      _MAX = amt + 1
      # 初始化 dp 表
      dp = Array.new(amt + 1, _MAX)
      dp[0] = 0
      # 狀態轉移
      for i in 1...(n + 1)
        # 正序走訪
        for a in 1...(amt + 1)
          if coins[i - 1] > a
            # 若超過目標金額，則不選硬幣 i
            dp[a] = dp[a]
          else
            # 不選和選硬幣 i 這兩種方案的較小值
            dp[a] = [dp[a], dp[a - coins[i - 1]] + 1].min
          end
        end
      end
      dp[amt] != _MAX ? dp[amt] : -1
    end

coin_change.zig

    // 零錢兌換：空間最佳化後的動態規劃
    fn coinChangeDPComp(comptime coins: []i32, comptime amt: usize) i32 {
        comptime var n = coins.len;
        comptime var max = amt + 1;
        // 初始化 dp 表
        var dp = [_]i32{0} ** (amt + 1);
        @memset(&dp, max);
        dp[0] = 0;
        // 狀態轉移
        for (1..n + 1) |i| {
            for (1..amt + 1) |a| {
                if (coins[i - 1] > @as(i32, @intCast(a))) {
                    // 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a];
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[a] = @min(dp[a], dp[a - @as(usize, @intCast(coins[i - 1]))] + 1);
                }
            }
        }
        if (dp[amt] != max) {
            return @intCast(dp[amt]);
        } else {
            return -1;
        }
    }

視覺化執行

全螢幕觀看 >

## 14.5.3 零錢兌換問題 II

Question

給定 \(n\) 種硬幣，第 \(i\) 種硬幣的面值為 \(coins[i - 1]\) ，目標金額為 \(amt\) ，每種硬幣可以重複選取，問湊出目標金額的硬幣組合數量。示例如圖 14-26 所示。

圖 14-26 零錢兌換問題 II 的示例資料

### 1. 動態規劃思路

相比於上一題，本題目標是求組合數量，因此子問題變為：前 \(i\) 種硬幣能夠湊出金額 \(a\) 的組合數量。而 \(dp\) 表仍然是尺寸為 \((n+1) \times (amt + 1)\) 的二維矩陣。

當前狀態的組合數量等於不選當前硬幣與選當前硬幣這兩種決策的組合數量之和。狀態轉移方程為：

\[ dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] \]

當目標金額為 \(0\) 時，無須選擇任何硬幣即可湊出目標金額，因此應將首列所有 \(dp[i, 0]\) 都初始化為 \(1\) 。當無硬幣時，無法湊出任何 \(>0\) 的目標金額，因此首行所有 \(dp[0, a]\) 都等於 \(0\) 。

### 2. 程式碼實現

Python C++Java C#Go Swift JS TS Dart Rust C Kotlin Ruby Zig
coin_change_ii.py

    def coin_change_ii_dp(coins: list[int], amt: int) -> int:
        """零錢兌換 II：動態規劃"""
        n = len(coins)
        # 初始化 dp 表
        dp = [[0] * (amt + 1) for _ in range(n + 1)]
        # 初始化首列
        for i in range(n + 1):
            dp[i][0] = 1
        # 狀態轉移
        for i in range(1, n + 1):
            for a in range(1, amt + 1):
                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]

coin_change_ii.cpp

    /* 零錢兌換 II：動態規劃 */
    int coinChangeIIDP(vector<int> &coins, int amt) {
        int n = coins.size();
        // 初始化 dp 表
        vector<vector<int>> dp(n + 1, vector<int>(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];
    }

coin_change_ii.java

    /* 零錢兌換 II：動態規劃 */
    int coinChangeIIDP(int[] coins, int amt) {
        int n = coins.length;
        // 初始化 dp 表
        int[][] dp = new int[n + 1][amt + 1];
        // 初始化首列
        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];
    }

coin_change_ii.cs

    /* 零錢兌換 II：動態規劃 */
    int CoinChangeIIDP(int[] coins, int amt) {
        int n = coins.Length;
        // 初始化 dp 表
        int[,] dp = new int[n + 1, amt + 1];
        // 初始化首列
        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];
    }

coin_change_ii.go

    /* 零錢兌換 II：動態規劃 */
    func coinChangeIIDP(coins []int, amt int) int {
        n := len(coins)
        // 初始化 dp 表
        dp := make([][]int, n+1)
        for i := 0; i <= n; i++ {
            dp[i] = make([]int, amt+1)
        }
        // 初始化首列
        for i := 0; i <= n; i++ {
            dp[i][0] = 1
        }
        // 狀態轉移：其餘行和列
        for i := 1; i <= n; i++ {
            for 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]
    }

coin_change_ii.swift

    /* 零錢兌換 II：動態規劃 */
    func coinChangeIIDP(coins: [Int], amt: Int) -> Int {
        let n = coins.count
        // 初始化 dp 表
        var dp = Array(repeating: Array(repeating: 0, count: amt + 1), count: n + 1)
        // 初始化首列
        for i in 0 ... n {
            dp[i][0] = 1
        }
        // 狀態轉移
        for i in 1 ... n {
            for a in 1 ... amt {
                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]
    }

coin_change_ii.js

    /* 零錢兌換 II：動態規劃 */
    function coinChangeIIDP(coins, amt) {
        const n = coins.length;
        // 初始化 dp 表
        const dp = Array.from({ length: n + 1 }, () =>
            Array.from({ length: amt + 1 }, () => 0)
        );
        // 初始化首列
        for (let i = 0; i <= n; i++) {
            dp[i][0] = 1;
        }
        // 狀態轉移
        for (let i = 1; i <= n; i++) {
            for (let 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];
    }

coin_change_ii.ts

    /* 零錢兌換 II：動態規劃 */
    function coinChangeIIDP(coins: Array<number>, amt: number): number {
        const n = coins.length;
        // 初始化 dp 表
        const dp = Array.from({ length: n + 1 }, () =>
            Array.from({ length: amt + 1 }, () => 0)
        );
        // 初始化首列
        for (let i = 0; i <= n; i++) {
            dp[i][0] = 1;
        }
        // 狀態轉移
        for (let i = 1; i <= n; i++) {
            for (let 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];
    }

coin_change_ii.dart

    /* 零錢兌換 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];
    }

coin_change_ii.rs

    /* 零錢兌換 II：動態規劃 */
    fn coin_change_ii_dp(coins: &[i32], amt: usize) -> i32 {
        let n = coins.len();
        // 初始化 dp 表
        let mut dp = vec![vec![0; amt + 1]; n + 1];
        // 初始化首列
        for i in 0..=n {
            dp[i][0] = 1;
        }
        // 狀態轉移
        for i in 1..=n {
            for a in 1..=amt {
                if coins[i - 1] > a as i32 {
                    // 若超過目標金額，則不選硬幣 i
                    dp[i][a] = dp[i - 1][a];
                } else {
                    // 不選和選硬幣 i 這兩種方案之和
                    dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1] as usize];
                }
            }
        }
        dp[n][amt]
    }

coin_change_ii.c

    /* 零錢兌換 II：動態規劃 */
    int coinChangeIIDP(int coins[], int amt, int coinsSize) {
        int n = coinsSize;
        // 初始化 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;
        }
        // 狀態轉移
        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]];
                }
            }
        }
        int res = dp[n][amt];
        // 釋放記憶體
        for (int i = 0; i <= n; i++) {
            free(dp[i]);
        }
        free(dp);
        return res;
    }

coin_change_ii.kt

    /* 零錢兌換 II：動態規劃 */
    fun coinChangeIIDP(coins: IntArray, amt: Int): Int {
        val n = coins.size
        // 初始化 dp 表
        val dp = Array(n + 1) { IntArray(amt + 1) }
        // 初始化首列
        for (i in 0..n) {
            dp[i][0] = 1
        }
        // 狀態轉移
        for (i in 1..n) {
            for (a in 1..amt) {
                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]
    }

coin_change_ii.rb

    ### 零錢兌換 II：動態規劃 ###
    def coin_change_ii_dp(coins, amt)
      n = coins.length
      # 初始化 dp 表
      dp = Array.new(n + 1) { Array.new(amt + 1, 0) }
      # 初始化首列
      (0...(n + 1)).each { |i| dp[i][0] = 1 }
      # 狀態轉移
      for i in 1...(n + 1)
        for a in 1...(amt + 1)
          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]]
          end
        end
      end
      dp[n][amt]
    end

coin_change_ii.zig

    // 零錢兌換 II：動態規劃
    fn coinChangeIIDP(comptime coins: []i32, comptime amt: usize) i32 {
        comptime var n = coins.len;
        // 初始化 dp 表
        var dp = [_][amt + 1]i32{[_]i32{0} ** (amt + 1)} ** (n + 1);
        // 初始化首列
        for (0..n + 1) |i| {
            dp[i][0] = 1;
        }
        // 狀態轉移
        for (1..n + 1) |i| {
            for (1..amt + 1) |a| {
                if (coins[i - 1] > @as(i32, @intCast(a))) {
                    // 若超過目標金額，則不選硬幣 i
                    dp[i][a] = dp[i - 1][a];
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[i][a] = dp[i - 1][a] + dp[i][a - @as(usize, @intCast(coins[i - 1]))];
                }
            }
        }
        return dp[n][amt];
    }

視覺化執行

全螢幕觀看 >

### 3. 空間最佳化

空間最佳化處理方式相同，刪除硬幣維度即可：

Python C++Java C#Go Swift JS TS Dart Rust C Kotlin Ruby Zig
coin_change_ii.py

    def coin_change_ii_dp_comp(coins: list[int], amt: int) -> int:
        """零錢兌換 II：空間最佳化後的動態規劃"""
        n = len(coins)
        # 初始化 dp 表
        dp = [0] * (amt + 1)
        dp[0] = 1
        # 狀態轉移
        for i in range(1, n + 1):
            # 正序走訪
            for a in range(1, amt + 1):
                if coins[i - 1] > a:
                    # 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a]
                else:
                    # 不選和選硬幣 i 這兩種方案之和
                    dp[a] = dp[a] + dp[a - coins[i - 1]]
        return dp[amt]

coin_change_ii.cpp

    /* 零錢兌換 II：空間最佳化後的動態規劃 */
    int coinChangeIIDPComp(vector<int> &coins, int amt) {
        int n = coins.size();
        // 初始化 dp 表
        vector<int> dp(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];
    }

coin_change_ii.java

    /* 零錢兌換 II：空間最佳化後的動態規劃 */
    int coinChangeIIDPComp(int[] coins, int amt) {
        int n = coins.length;
        // 初始化 dp 表
        int[] dp = new int[amt + 1];
        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];
    }

coin_change_ii.cs

    /* 零錢兌換 II：空間最佳化後的動態規劃 */
    int CoinChangeIIDPComp(int[] coins, int amt) {
        int n = coins.Length;
        // 初始化 dp 表
        int[] dp = new int[amt + 1];
        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];
    }

coin_change_ii.go

    /* 零錢兌換 II：空間最佳化後的動態規劃 */
    func coinChangeIIDPComp(coins []int, amt int) int {
        n := len(coins)
        // 初始化 dp 表
        dp := make([]int, amt+1)
        dp[0] = 1
        // 狀態轉移
        for i := 1; i <= n; i++ {
            // 正序走訪
            for 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]
    }

coin_change_ii.swift

    /* 零錢兌換 II：空間最佳化後的動態規劃 */
    func coinChangeIIDPComp(coins: [Int], amt: Int) -> Int {
        let n = coins.count
        // 初始化 dp 表
        var dp = Array(repeating: 0, count: amt + 1)
        dp[0] = 1
        // 狀態轉移
        for i in 1 ... n {
            for a in 1 ... amt {
                if coins[i - 1] > a {
                    // 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a]
                } else {
                    // 不選和選硬幣 i 這兩種方案之和
                    dp[a] = dp[a] + dp[a - coins[i - 1]]
                }
            }
        }
        return dp[amt]
    }

coin_change_ii.js

    /* 零錢兌換 II：空間最佳化後的動態規劃 */
    function coinChangeIIDPComp(coins, amt) {
        const n = coins.length;
        // 初始化 dp 表
        const dp = Array.from({ length: amt + 1 }, () => 0);
        dp[0] = 1;
        // 狀態轉移
        for (let i = 1; i <= n; i++) {
            for (let 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];
    }

coin_change_ii.ts

    /* 零錢兌換 II：空間最佳化後的動態規劃 */
    function coinChangeIIDPComp(coins: Array<number>, amt: number): number {
        const n = coins.length;
        // 初始化 dp 表
        const dp = Array.from({ length: amt + 1 }, () => 0);
        dp[0] = 1;
        // 狀態轉移
        for (let i = 1; i <= n; i++) {
            for (let 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];
    }

coin_change_ii.dart

    /* 零錢兌換 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];
    }

coin_change_ii.rs

    /* 零錢兌換 II：空間最佳化後的動態規劃 */
    fn coin_change_ii_dp_comp(coins: &[i32], amt: usize) -> i32 {
        let n = coins.len();
        // 初始化 dp 表
        let mut dp = vec![0; amt + 1];
        dp[0] = 1;
        // 狀態轉移
        for i in 1..=n {
            for a in 1..=amt {
                if coins[i - 1] > a as i32 {
                    // 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a];
                } else {
                    // 不選和選硬幣 i 這兩種方案之和
                    dp[a] = dp[a] + dp[a - coins[i - 1] as usize];
                }
            }
        }
        dp[amt]
    }

coin_change_ii.c

    /* 零錢兌換 II：空間最佳化後的動態規劃 */
    int coinChangeIIDPComp(int coins[], int amt, int coinsSize) {
        int n = coinsSize;
        // 初始化 dp 表
        int *dp = calloc(amt + 1, sizeof(int));
        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]];
                }
            }
        }
        int res = dp[amt];
        // 釋放記憶體
        free(dp);
        return res;
    }

coin_change_ii.kt

    /* 零錢兌換 II：空間最佳化後的動態規劃 */
    fun coinChangeIIDPComp(coins: IntArray, amt: Int): Int {
        val n = coins.size
        // 初始化 dp 表
        val dp = IntArray(amt + 1)
        dp[0] = 1
        // 狀態轉移
        for (i in 1..n) {
            for (a in 1..amt) {
                if (coins[i - 1] > a) {
                    // 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a]
                } else {
                    // 不選和選硬幣 i 這兩種方案之和
                    dp[a] = dp[a] + dp[a - coins[i - 1]]
                }
            }
        }
        return dp[amt]
    }

coin_change_ii.rb

    ### 零錢兌換 II：空間最佳化後的動態規劃 ###
    def coin_change_ii_dp_comp(coins, amt)
      n = coins.length
      # 初始化 dp 表
      dp = Array.new(amt + 1, 0)
      dp[0] = 1
      # 狀態轉移
      for i in 1...(n + 1)
        # 正序走訪
        for a in 1...(amt + 1)
          if coins[i - 1] > a
            # 若超過目標金額，則不選硬幣 i
            dp[a] = dp[a]
          else
            # 不選和選硬幣 i 這兩種方案之和
            dp[a] = dp[a] + dp[a - coins[i - 1]]
          end
        end
      end
      dp[amt]
    end

coin_change_ii.zig

    // 零錢兌換 II：空間最佳化後的動態規劃
    fn coinChangeIIDPComp(comptime coins: []i32, comptime amt: usize) i32 {
        comptime var n = coins.len;
        // 初始化 dp 表
        var dp = [_]i32{0} ** (amt + 1);
        dp[0] = 1;
        // 狀態轉移
        for (1..n + 1) |i| {
            for (1..amt + 1) |a| {
                if (coins[i - 1] > @as(i32, @intCast(a))) {
                    // 若超過目標金額，則不選硬幣 i
                    dp[a] = dp[a];
                } else {
                    // 不選和選硬幣 i 這兩種方案的較小值
                    dp[a] = dp[a] + dp[a - @as(usize, @intCast(coins[i - 1]))];
                }
            }
        }
        return dp[amt];
    }

視覺化執行

全螢幕觀看 >

#####