LeetCode动态规划之背包问题

LeetCode动态规划之背包问题

0-1背包问题

给一个可以装重量为M的背包，和N个物品，每个物品有重量和价值两种属性，分别存放在数组wt[i]和val[i]中，请问使用这个背包，最多能装多少价值的物品？

public int maxVal(int M, int N, int[] wt, int[] val) {
    //dp[i][j]表示 对于前i个物品，承重为j的背包可以存储的最大价值
    int[][] dp = new int[N + 1][M + 1];
    //遍历所有的状态
    for (int i = 0; i <= N; i++) {
        for (int j = 0; j <= M; j++) {
            //basecase
            if (i == 0) {
                dp[0][j] = 0;
                continue;
            }
            if (j == 0) {
                dp[j][0] = 0;
                continue;
            }
            //当前物品放不下
            if (j < wt[i - 1]) {
                dp[i][j] = dp[i - 1][j];
            } else {
                //两种选择，拿 或者 不拿
                dp[i][j] = Math.max(dp[i - 1][j - wt[i - 1]] + val[i - 1], dp[i - 1][j]);
            }
        }
    }
    return dp[N][M];
}

子集背包问题

416. 分割等和子集

转换成背包问题：有n个物品，重量保存在 nums[] 中，是否存在一种装法，可以正好装满sum/2的背包？

public boolean canPartition(int[] nums) {
    int sum = 0;
    int n = nums.length;
    for (int i = 0; i < n; i++) {
        sum += nums[i];
    }
    if (sum % 2 == 1) {
        return false;
    }
    //dp[i][j]表示对于前i个物体，是否存在一种方法，可以正好塞满承重为j的背包
    boolean[][] dp = new boolean[n + 1][sum / 2 + 1];
    //遍历所有状态
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= sum / 2; j++) {
            //basecase
            if (i == 0 && j == 0) {
                dp[0][0] = true;
                continue;
            }
            // if (i == 0 || j == 0) {
            // continue;
            // }
            if(i == 0){
                continue;
            }
            //装不下
            if (j < nums[i - 1]) {
                dp[i][j] = dp[i - 1][j];
            }
            //装得下
            else {
                //装
                if (dp[i - 1][j - nums[i - 1]]) {
                    dp[i][j] = true;
                }
                //不装
                else {
                    dp[i][j] = dp[i - 1][j];
                }
            }

        }
    }
    return dp[n][sum / 2];
}

完全背包问题

322. 零钱兑换

public int coinChange(int[] coins, int amount) {
    // dp[i]表示凑成总金额i的最少的硬币个数
    // 结果就是dp[amount]
    int[] dp = new int[amount + 1];
    // 将dp[]设置为一个不可能出现的较大值
    Arrays.fill(dp, amount + 1);
    // basecase:凑成总金额为0所需的硬币数为0
    dp[0] = 0;
    //3.遍历所有【状态】
    for (int i = 0; i < amount + 1; i++) {
        //4.遍历所有【选择】
        for (int coin : coins) {
            //子问题无解，则跳过
            if (i - coin < 0) continue;
            dp[i] = Math.min(dp[i], dp[i - coin] + 1);
        }
    }
    return (dp[amount] == amount + 1) ? -1 : dp[amount];
}

518. 零钱兑换 II

给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有【无限个】。

public int change(int amount, int[] coins) {
    int n = coins.length;
    //dp[i][j] 表示 使用前i种面额的硬币，能凑成j元的组合数
    int[][] dp = new int[n + 1][amount + 1];
    //遍历所有状态
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= amount; j++) {
            //basecase
            if (j == 0) {
                dp[i][0] = 1;
                continue;
            }
            if (i == 0) {
                continue;
            }
            //装不下
            if (j < coins[i - 1]) {
                dp[i][j] = dp[i - 1][j];
            } else {
                //装 或者 不装
                //注意不是求最值，而是求和
                //dp[i][j] = Math.max(dp[i-1][j],dp[i][j-coins[i-1]]);
                dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i - 1]];
            }
        }
    }
    return dp[n][amount];
}