畅游面试中的动态规划套路-完全背包系列

2.完全背包

索引链接：畅游面试中的动态规划套路

Cutting Rod

方法1:暴力递归

• 代码略

方法2:自顶向下记忆化递归(Top-down)

        Integer[][] cache;
        int[] lengths;
        int[] prices;

        public int rodCutting(int[] lengths, int[] prices, int rodlength) {
            this.lengths = lengths;
            this.prices = prices;
            cache = new Integer[lengths.length][rodlength + 1];//
            return helper(rodlength, 0);
        }


        private int helper(int rodlength, int curIdx) {
            if (curIdx >= lengths.length) return 0;
            if (cache[curIdx][rodlength] != null) return cache[curIdx][rodlength];
            int choose = 0;//选
            if (lengths[curIdx] <= rodlength) {
                choose = prices[curIdx] + helper(rodlength - lengths[curIdx], curIdx);
            }
            int non_choose = helper(rodlength, curIdx + 1);//不选
            return cache[curIdx][rodlength] = Math.max(choose, non_choose);
        }

方法3:自底向上填表DP(Bottom-up)

     public int rodCutting(int[] lengths, int[] prices, int n) {
            int m = lengths.length;
            int[][] f = new int[m][n + 1];
            for (int i = 0; i < m; i++) {
                for (int j = 1; j <= n; j++) {
                    int choose = 0, non_choose = 0;
                    if (lengths[i] <= j) choose = prices[i] + f[i][j - lengths[i]];
                    if (i > 0) non_choose = f[i - 1][j];
                    f[i][j] = Math.max(choose, non_choose);
                }
            }
            return f[m - 1][n];
        }

• 测试

            _2nd handler = new _2nd();
            int[] lengths = {1, 2, 3, 4, 5};//每一根木棒的长度
            int[] prices = {2, 6, 7, 10, 13};//每一根木棒的利润
            int rodlength = 5;
            System.out.println(handler.rodCutting(lengths, prices, rodlength));

零钱兑换

题目链接：322. 零钱兑换

题解链接：畅游面试中的动态规划套路-完全背包系列之零钱兑换

零钱兑换问题的Follow Up 1

Follow Up指的是面试过程中的追问环节，包括但不限于已有问题的举一反三，边界条件，优化方案

• $base$题是基于这一题：给定不同面额的硬币$ coins$ 和一个总金额 $amount$。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1, 你可以认为每种硬币的数量是无限的。

Step 1 零钱兑换问题(01背包)

题目描述：给定不同面额的硬币$ coins$ 和一个总金额 $amount$。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1, 但是每个硬币只能选择一次

题目分析

• 因为提到了每个硬币只能选择一次，这个与**01背包**很吻合

---

这是01背包的抽象模型

参数定义：

• $N$件物品
• $V$背包的总容量
• $Ci$放入第$i$件物品耗费的费用
• $Wi$放入第$i$件物品得到的价值

定义状态

$F[i,v]$表示前$i$件物品恰好放入一个容量为$v$的背包可以获得的最大价值

选择

转移方程应为是：$F[i,v]=max(F[i-1,v],F[i-1,v-Ci]+Wi)$

• 解释：将第$i$件物品放入容量为$v$的背包中，只需要基于$i-1$件物品的基础上做第$i$件物品的放与不放的问题
  • 不放入第$i$件物品，获得的最大价值是$F[i-1,v]$
  • 放入第$i$件物品，获得的最大价值是$F[i-1,v-Ci]+Wi$,因为第$i$件物品已经放进去背包了，留给前$i-1$件物品的背包容量只有$v-Ci$,而通过放入第$i$件物品，获取的价值是$Wi$

边界条件

• $dp[0][0]$表示当选择是$0$个物品时，在没有物品，背包体积为$0$时，不装任何东西的时候$dp[0][0]=0$
• $F[i-1,v-Ci]$其中$v>=Ci$，不然为负数，没有意义

---

回到本题

定义状态

• $F[i,v]$表示前$i$件物品恰好放入一个容量为$v$的背包可以获得的最大价值，套用到本题即，$dp[i][j]$表示前$i$个硬币，组成目标金额为$j$的最少硬币数量。

选择

• 根据上文中的01背包的抽象模型，$dp[i][j]$依赖于对于第$i$个硬币拿与不拿这两种选择
  • 不拿:$dp[i-1][j]$,相当于前$i-1$个硬币选择，组成目标金额$j$的最少硬币
  • 拿:$dp[i-1][j-coins[i]]+1$，从前$i-1$个硬币选择，组成目标金额$j-coins[i]$，因为拿了第$i$个硬币，所有选择方案上的硬币数量需要$+1$
  • 最终的动态转移方程:$dp[i][j]=min(dp[i-1][j],dp[i-1][j-coins[i]+1])$

边界条件

• $dp[amount+1]$，表示从$0$到$amount$的所有状态，初始化时，全部置为$inf$，为了最后找到有些情况不可达，返回-1的结果
• $dp[0]=0$，组成目标金额为$0$的硬币选择方案，即什么硬币都不选，最少硬币为$0$个

只给出了一维数组$dp$版，其他版本可参见底部的阅读

    def coinChange(self, coins: List[int], amount: int) -> int:
        n = len(coins)
        # 初始化数组 dp[amount+1] 为 float('inf')
        dp = [float('inf') for i in range(amount + 1)]
        dp[0] = 0
        for i in range(1, n + 1):
            for j in range(amount, coins[i - 1], -1):
                dp[j] = min(dp[j], dp[j - coins[i]] + 1)
        return dp[amount] if dp[amount] != float('inf') else -1

Step 2 零钱兑换问题(完全背包)

题目描述：给定不同面额的硬币$ coins$ 和一个总金额 $amount$。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1, 每个硬币可以选择无数次

题目分析

• 因为提到了每个硬币可以选择无数次，这个与**完全背包**很吻合

---

这是完全背包的抽象模型

参数定义：

• $N$件物品
• $V$背包的总容量
• $Ci$放入第$i$件物品耗费的费用
• $Wi$放入第$i$件物品得到的价值动态规划的几大要素：状态，选择以及边界条件

每件物品可以 取用0件，1件，2件…$V/Ci$件，

定义状态

• $F[i,v]$表示前$i$个物品恰好放入容量为$v$的背包时获取到的最大价值，很容易得到如下的动态转移方程：
  • $F[i,v]=max(F[i-1,v-kCi]+kWi|kCi\in [0,v])$

边界条件

• 如果创建一个$dp=int[N+1][V+1]$的二维动态数组，当$dp[0][0]$时，表示的时物品数与背包的容量都是$0$的，显然其结果为$0$

---

回到本题

• $dp[amount+1]$，初始化$dp[0]=0$,表示欲组成总金额为$0$硬币的最少个数，为$0$,一个硬币都不取
• $dp[j]$:使用$coins$组成目标金额为$j$的最少硬币数量
• 动态转移方程：$dp[j]=min(dp[j],dp[j-coins[i-1]]+1)$ 其中$i-1$表示的是第$i$个硬币

    def change(self, coins: List[int], amount: int) -> int:
        # 初始化数组 dp[amount+1] 为 float('inf')
        dp = [float('inf') for i in range(amount + 1)]
        dp[0] = 0
        for coin in coins:
            for j in range(coin, amount + 1):
                dp[j] = min(dp[j], dp[j - coin] + 1)
        return dp[amount] if dp[amount] != float('inf') else -1

Step 3 零钱兑换问题(多重背包)

题目描述：给定不同面额的硬币$ coins$ 和一个总金额 $amount$，每个硬币的选择次数有限制，上限$t$次，编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1

题目分析

• 因为提到了每个硬币的选择次数有限制，上限$t$次，这个与**多重背包**很吻合

定义状态

• 对于第$i$中硬币，可以由0 ,1 2…k 到t 次 的选择，$dp[i][j]$表示前$i$个硬币组成金额为$j$时的最少硬币数量

dp[i][j] = 
min(dp[i-1]dp[j],
	dp[i-1][j-c]+1, 
	dp[i-1][j-2*c]+2, 
	...,
	dp[i-1][j-k*c]+k)
	其中k∈[1,t]

• 代码：

    def change(self, coins: List[int], amount: int, t: List[int]) -> int:
        dp = [float('inf') for i in range(amount + 1)]
        dp[0] = 0
        for i in range(len(coins)):
            for j in range(amount, coins[i] - 1, -1):
                for k in range(1, t[i] + 1): 
                    if j >= k * coins[i]:  
                        dp[j] = min(dp[j], dp[j - k * coins[i]] + k)
        return -1 if dp[amount] > amount else dp[amount]

• 选str[k-1]这个字符时
• 不选str[k-1]这个字符时

其中$cost\_zero[k]$ 和 $cost\_one[k]$,是到达第$k-1$个字符串的时候，这个字符串中0和1的数量，因为数据的下标索引小于0是无意义的

边界

每个维度+1，第0个字符是空字符串

    public int findMaxForm(String[] strs, int m, int n) {
        int len = strs.length;
        int[][][] dp = new int[len + 1][m + 1][n + 1];
        for (int k = 1; k < len + 1; ++k) {
            int[] counter = counter(strs[k - 1]);
            for (int i = 0; i < m + 1; ++i) {
                for (int j = 0; j < n + 1; ++j) {
                    if (i >= counter[0] && j >= counter[1]) {
                        dp[k][i][j] = Math.max(dp[k][i][j],
                                dp[k - 1][i - counter[0]][j - counter[1]] + 1);
                    }
                    dp[k][i][j] = Math.max(dp[k][i][j], dp[k - 1][i][j]);
                }
            }
        }
        return dp[len][m][n];
    }

    /**
     * 计算str字符串中的 0和1的个数， counter[0] 是 "0"的个数，counter[1]是"1"的个数
     *
     * @param str
     * @return
     */
    public int[] counter(String str) {
        int[] counter = new int[2];
        for (char c : str.toCharArray()) counter[c - '0']++;
        return counter;
    }

方法4:自底向上填表DP(Bottom-up)-空间压缩

动态规划的几大要素：状态，选择以及边界条件

参数定义：

• $N$件物品
• $V$背包的总容量
• $Ci$放入第$i$件物品耗费的费用
• $Wi$放入第$i$件物品得到的价值

定义状态

$F[i,v]$表示前$i$件物品恰好放入一个容量为$v$的背包可以获得的最大价值，而转移方程应为是：$F[i,v]=max(F[i-1,v],F[i-1,v-Ci]+Wi)$

• 解释：将第$i$件物品放入容量为$v$的背包中，只需要基于$i-1$件物品的基础上做第$i$件物品的放与不放的问题
  • 不放入第$i$件物品，获得的最大价值是$F[i-1,v]$
  • 放入第$i$件物品，获得的最大价值是$F[i-1,v-Ci]+Wi$,因为第$i$件物品已经放进去背包了，留给前$i-1$件物品的背包容量只有$v-Ci$,而通过放入第$i$件物品，获取的价值是$Wi$

边界条件

• $dp[0][0]$表示当选择是$0$个物品时，在没有物品，背包体积为$0$时，不装任何东西的时候$dp[0][0]=0$
• $F[i-1,v-Ci]$其中$v>=Ci$，不然为负数，没有意义

核心代码

dp[N+1][V+1]
dp[0][0...V]=0
dp[0...N][0]=0
for i in range(1,N+1)
	for j in range(1,V+1)
    	dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i])

上面是01背包的模型

定义状态

$dp[i][j]$ 表示遍历到第$k$个字符的时候，使用$i$个0，$j$个1的时候，能够拼出的字符串的数量，即个数

    public int findMaxForm(String[] strs, int m, int n) {
        int len = strs.length;
        int[][] dp = new int[m + 1][n + 1];
        for (String str : strs) {
            int[] counter = counter(str);
            for (int i = m; i >= counter[0]; i--) {
                for (int j = n; j >= counter[1]; j--) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - counter[0]][j - counter[1]] + 1);
                }
            }
        }
        return dp[m][n];
    }

    /**
     * 计算str字符串中的 0和1的个数， counter[0] 是 "0"的个数，counter[1]是"1"的个数
     *
     * @param str
     * @return
     */
    public int[] counter(String str) {
        int[] counter = new int[2];
        for (char c : str.toCharArray()) counter[c - '0']++;
        return counter;
    }

零钱兑换II

题目链接：518. 零钱兑换 II

题解链接：背包思想解决零钱兑换问题(逐步优化，多方法)

题目分析

• 假设每一种面额的硬币有无限个 这是题目描述的，符合完全背包问题:每件物品可以无限制的取用，只要不超过总的背包容量，把背包撑爆

• 完全背包的抽象模型，参见前文

方法1:朴素版(三层循环)

定义状态

• $dp[i][j]$: $coins[0..i]$范围内的硬币，组成目标金额为$j$，能得到的组合数
• 当遇到一种新的硬币$coins[i]$时，可以选$0$种，$1$种，$2$种，直到$k$种，因为可以对于一种硬币进行无数种选择，只要$j-coins[i-1]\ge 0$即可，不满足这个条件，背包撑爆，对于这个状态本身没有什么意义，将上面的每个子状态的和累加，即是所求$dp[i][j]$
  • 动态转移方程：$ \sum_{0}^k dp[i-1][j-k*coins[i-1]] $

边界条件

• 多设置一行，$dp=int[n+1][...]$ 将$dp[0][0]$置为$1$，其他为$0$

    public int change1st(int amount, int[] coins) {
        int n = coins.length;
        int[][] dp = new int[n + 1][amount + 1];
        dp[0][0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= amount; j++) {
                for (int k = 0; k * coins[i - 1] <= j; k++) {
                    dp[i][j] += dp[i - 1][j - k * coins[i - 1]];
                }
            }
        }
        return dp[n][amount];
    }

复杂度分析

• 时间复杂度：$O(N\ast amoun{t}^2)$其中$N$是硬币的个数即$coins$数组的长度，$amount$是金额
• 空间复杂度：$O(N\ast amount)$,即$dp$使用的空间

方法2：优化(两层循环)

定义状态

• $dp[i][j]$：$coins[0....i-1]$这前$i$个硬币，组成金额为$j$，能得到的组合数
• $dp[i][j]$依赖于两个状态，选不选$coins[i-1]$这个硬币，
  • 不选的时候为$dp[i-1][j]$,不选$coins[i-1]$时，只能在前$i-1$个硬币中组成$j$
  • 选的时候为$dp[i][j-coins[i-1]]$，选$coins[i-1]$时，总的金额减少到$j-coins[i-1]$,但由于是完全背包问题，每个物品可以选无限次，所以，剩下的可以选的硬币还是应该是$coins[0...i-1]$前$i$个
  • 状态转移方程：$dp[i][j]$=$dp[i-1][j]$+$dp[i][j-coins[i-1]]$，这其中可以做个优化，$j-coins[i-1]<0$的情况无意义，可以过滤

边界条件

• $dp[i][0]$前$i$个硬币形成金额为$0$的组合数，为$1$那就是不选任何硬币，只有这$1$种选法
• $dp[0][j]$其中$j\ne 0$，前$0$种硬币组成目标金额为$j$的组合数，初始化时，$dp==int[n+1][...]$前$0$种硬币其实是没有硬币的，翻译下来是没有硬币，如何组成$j$，答案显然是$0$
• 注意在初始化$dp[0][j]$时，不要将$dp[0][0]$的状态覆盖掉了

结果

• $dp[n][amount]$前$n$中硬币形成了$amount$的组合数，即$coins[0...n-1]$形成了$amount$

    public int change2nd(int amount, int[] coins) {
    	int n = coins.length;
        int[][] dp = new int[n + 1][amount + 1];
        for (int i = 0; i <= n; i++) dp[i][0] = 1;
        for (int j = 1; j <= amount; j++) dp[0][j] = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= amount; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j - coins[i - 1] >= 0) dp[i][j] += dp[i][j - coins[i - 1]];
            }
        }
        return dp[n][amount];
    }

复杂度分析

• 时间复杂度：$O(N\ast amount)$其中$N$是硬币的个数即$coins$数组的长度，$amount$是金额

• 空间复杂度：$O(N\ast amount)$,即$dp$使用的空间

• 相比于方法1,优化了一层循环，时间复杂度变好

方法3：优化(一维数组)

定义状态

• 将方法2中的$dp[i][j]=dp[i-1][j]+dp[i][j-coins[i-1]];$去掉一维$i$得到，$dp[j]=dp[j+dp[j-coins[i]]]$这里$i$从$0$开始的，不需要取$coins[i-1]$

边界条件

• 没有硬币时候，不选任何硬币，可以组成金额为$0$，只有这么一种组合，$dp[0]$等价于$dp[0][0]$

 public int change3rd(int amount, int[] coins) {
        int n = coins.length;
        int[] dp = new int[amount + 1];
        dp[0] = 1;
        for (int i = 0; i < n; i++) {
            for (int j = coins[i]; j <= amount; j++) {
                dp[j] = dp[j] + dp[j - coins[i]];
            }
        }
        return dp

复杂度分析

• 时间复杂度：$O(N\ast amount)$其中$N$是硬币的个数即$coins$数组的长度，$amount$是金额
• 空间复杂度：$O(amount)$,即$dp$使用的空间，将二维降低为一维