背包问题——NWU_LK

背包问题题目

0-1背包

即每个物品可以拿一次

1. 分割等和子集（416题）
   

class Solution {
    public boolean canPartition(int[] nums) {
        if (nums.length==0) return false;
        int sum=0,n=0;
        for (int num : nums) {
            sum+=num;
        }
        if (sum%2!=0) return false;
        int target = sum/2;
        int[] dp=new int[target+1];
        for (int i=0;i<nums.length;i++){
            for (int j=target;j>=nums[i];j--){
                dp[j]=Math.max(dp[j-nums[i]]+nums[i],dp[j]);
            }
        }
        return dp[target]==target;
    }
}

2. 最后一块石头的重量 II（1049题）
   
   主要思想是将石块尽可能分为等量的两堆，然后消去公共的就是最后的结果

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int i : stones) {
            sum += i;
        }
        int target = sum >> 1;
        //初始化dp数组
        int[] dp = new int[target + 1];
        for (int i = 0; i < stones.length; i++) {
            //采用倒序
            for (int j = target; j >= stones[i]; j--) {
                //两种情况，要么放，要么不放
                dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - 2 * dp[target];
    }
}

3. 目标和（494题）
   

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) sum += nums[i];
        if ((target + sum) % 2 != 0) return 0;
        int size = (target + sum) / 2;
        if(size < 0) size = -size;
        int[] dp = new int[size + 1];
        dp[0] = 1;
        for (int i = 0; i < nums.length; i++) {
            for (int j = size; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[size];
    }
}

4. 1和0（474题）
   

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        //dp[i][j]表示i个0和j个1时的最大子集
        int[][] dp = new int[m + 1][n + 1];
        int oneNum, zeroNum;
        for (String str : strs) {
            oneNum = 0;
            zeroNum = 0;
            for (char ch : str.toCharArray()) {
                if (ch == '0') {
                    zeroNum++;
                } else {
                    oneNum++;
                }
            }
            //倒序遍历
            for (int i = m; i >= zeroNum; i--) {
                for (int j = n; j >= oneNum; j--) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
                }
            }
        }
        return dp[m][n];
    }
}

完全背包

即每个物品可以拿多次

1. 零钱兑换二（）

因为求的是组合数，不要求钱有序，因此物品放外层循环

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

2. 组合总和四（377题）

因为求的目标是排序数，所以背包容量要放在外层

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int[] dp=new int[target+1];
        dp[0]=1;
        for (int i=0;i<=target;i++){
            for (int j=0;j<nums.length;j++){
                if (nums[j]<=i){
                    dp[i]+=dp[i-nums[j]];
                }
            }
        }
        return dp[target];
    }
}

3. 完全平方数（279题）
   

class Solution {
    public int numSquares(int n) {
        int sqrt = (int)Math.sqrt(n);
        int[] dp=new int[n+1];
        Arrays.fill(dp,Integer.MAX_VALUE);
        dp[0]=0;
        for (int i=1;i<=sqrt;i++){
            for (int j=i*i;j<=n;j++){
                if (dp[j-i*i]!=Integer.MAX_VALUE){
                    dp[j] = Math.min(dp[j],dp[j-i*i]+1);
                }
            }
        }
        return dp[n];
    }
}