代码随想录算法训练营第 37 天 | 322. 零钱兑换、279. 完全平方数、139. 单词拆分、多重背包

322. 零钱兑换

题目链接

递推公式：dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1

初始化：dp[0] = 0，其他为 Integer.MAX_VALUE。因为递推公式取的是 min。

也可以取 max = amount + 1，避免 Integer.MAX_VALUE + 1 溢出的情况。这样就 for 循环中就不需要 if 判断了。

class Solution {
    public int coinChange(int[] coins, int amount) {
        int n = coins.length;
        int[] dp = new int[amount + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;

        for (int i = 0; i < n; i++) {
            for (int j = coins[i]; j < amount + 1; j++) {
                if (dp[j - coins[i]] != Integer.MAX_VALUE) { // 只有dp[j-coins[i]]不是初始最大值时，该位才有选择的必要。否则根本到不了。
                    dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
                }
            }
        }

        return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
    }
}

279. 完全平方数

题目链接

class Solution {
    public int numSquares(int n) {
        int max = n + 1;
        int[] dp = new int[n + 1];
        Arrays.fill(dp, max);
        dp[0] = 0;

        for (int i = 1; i * i <= n; i++) { // i 最小从 1 开始
            for (int j = i * i; j <= n; j++) { // j 要大于等于 i * i
                dp[j] = Math.min(dp[j], dp[j - i * i] + 1);
            }
        }

        return dp[n];
    }
}

139. 单词拆分

题目链接

是排列问题，不是组合问题！
先遍历背包，再遍历物品。

“applepenapple”
dict = {“apple”, “pen”}，apple为 1，pen 为 2。
必须是排列顺序 121，不能是112

递推公式：
if (dp[j] == true && [j, i]) dp[i] = true

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        int n = s.length();
        HashSet<String> set = new HashSet<>(wordDict);

        boolean[] dp = new boolean[n + 1];
        dp[0] = true;
        for (int j = 1; j < n + 1; j++) {
            for (int i = 0; i < j; i++) {
                if (dp[i] && set.contains(s.substring(i, j))) {
                    dp[j] = true;
                    break;
                }
            }
        }

        return dp[n];
    }
}

小优化：为 true 后直接 break。

多重背包

题目链接

方法一：把 n 个物品拆成 1 + 1 + … + 1 个物品。

import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int bagWeight = sc.nextInt();
        int n = sc.nextInt();
        List<Integer> weights = new ArrayList<>();
        List<Integer> values = new ArrayList<>();
        int[] nums = new int[n];

        for (int i = 0; i < n; i++) {
            weights.add(sc.nextInt());
        }
        for (int i = 0; i < n; i++) {
            values.add(sc.nextInt());
        }
        for (int i = 0; i < n; i++) {
            nums[i] = sc.nextInt();
        }

        for (int i = 0; i < n; i++) {
            while (nums[i] > 1) { // 减到 1 为止
                weights.add(weights.get(i));
                values.add(values.get(i));
                nums[i]--;
            }
        }


        int[] dp = new int[bagWeight + 1];

        for (int i = 0; i < weights.size(); i++) { // 注意这里不能写 n 了
            for (int j = bagWeight; j >= weights.get(i); j--) {
                dp[j] = Math.max(dp[j], dp[j - weights.get(i)] + values.get(i));
            }
        }

        System.out.println(dp[bagWeight]);
    }
}

方法二：把每种商品遍历的个数放在 01 背包里面在遍历一遍。

一定先遍历物品、再倒序遍历背包、再遍历物品数量。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int bagWeight = sc.nextInt();
        int n = sc.nextInt();
        int[] weights = new int[n];
        int[] values = new int[n];
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            weights[i] = sc.nextInt();
        }
        for (int i = 0; i < n; i++) {
            values[i] = sc.nextInt();
        }
        for (int i = 0; i < n; i++) {
            nums[i] = sc.nextInt();
        }

        int[] dp = new int[bagWeight + 1];

        for (int i = 0; i < n; i++) {
            for (int j = bagWeight; j >= weights[i]; j--) { // 和 01 背包一样，还是先遍历物品、再遍历背包。后面补充个物品个数。
                for (int k = 1; k <= nums[i] && j >= k * weights[i]; k++) { // 注意这里的 j >= k * weights[i]
                    dp[j] = Math.max(dp[j], dp[j - k * weights[i]] + k * values[i]);
                }
            }
        }

        System.out.println(dp[bagWeight]);
    }
}