背包问题（416，494，474,322，518，139）_python给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分

 一、416. 分割等和子集

1.1 题目描述

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

1.2 代码

题解：https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/fen-ge-deng-he-zi-ji-by-leetcode-solution/

力扣

创建二维数组dp，包含 n 行，target+1 列。其中dp[i] [j] 表示从数组的[0,i] 下标范围内选取若干个正整数（可以是 0 个），是否存在一种选取方案使得被选取的正整数的和等于 j。初始时，dp 中的全部元素都是 false。

	public boolean canPartition(int[] nums) {
	int len = nums.length;
	int sum=0;
	for(int num:nums) {
		sum+=num;
	}
	if(sum%2!=0) return false;
	int target=sum/2;
	boolean dp[][]=new boolean[len][target+1];
    dp[0][0] = true;
    if (nums[0]<=target) dp[0][nums[0]]=true;
	for (int i = 1; i < len; i++) {
		for(int j=0;j <=target;j++) {
			dp[i][j] = dp[i - 1][j];
			if (nums[i] <= j) {
				dp[i][j]=dp[i-1][j] || dp[i-1][j-nums[i]];
			}
		}
		if (dp[i][target]) {//提前结束
			return true;
		}
	}
		 return dp[len-1][target];
	}

494. 目标和

 

class Solution494 {
    int count=0;
    public int findTargetSumWays(int[] nums, int target) {
        backing(nums,target,0,0);
        return count;
    }
 
    public void backing(int[] nums,int target,int curSum,int index){
        if (index==nums.length) {
            if (curSum==target){
                count++;
                return;
            }
        }else {
            backing(nums,target,curSum+nums[index],index+1);
            backing(nums,target,curSum-nums[index],index+1);
        }
    }
}

474. 一和零

题解

dp[i][j][k] 表示输入字符串在子区间 [0, i] 能够使用 j 个 0 和 k 个 1 的字符串的最大数量。

/**
 * 474. 一和零
 * dp[i][j][k] 表示输入字符串在子区间 [0, i] 能够使用 j 个 0 和 k 个 1 的字符串的最大数量。
 */
class Solution {
     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 i = 1; i <= len; i++) {
            int[] count=countZeroOne(strs[i-1]);
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    dp[i][j][k] = dp[i - 1][j][k];
                    if (count[0]<=j && count[1]<=k){
                        dp[i][j][k]=Math.max(dp[i-1][j][k],dp[i-1][j-count[0]][k-count[1]]+1);
                    }
                }
            }
        }
        return dp[len][m][n];
    }
    public int[] countZeroOne(String s){
        int[] count = new int[2];
        for (char ch:s.toCharArray()){
            count[ch-'0']++;
        }
        return count;
    }
}

 322. 零钱兑换

    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount + 1];
        Arrays.sort(coins);
        Arrays.fill(dp,amount+1);
        dp[0]=0;
        for (int i = 1; i <= amount; i++) {
            for (int coin : coins) {
                if (i >= coin) {
                    dp[i] = Math.min(dp[i], dp[i - coin]+1);
                }else break;
            }
        }
return dp[amount]>amount?-1:dp[amount];
    }

518. 零钱兑换 II

题解 

注意，此题是组合数，不是排列数，(1,2)和（2,1）视为一种，因此注意不要重复计算。 

/**
 * 518. 零钱兑换 II,有几种方式可以凑成总金额
 * 外层循环是coin，因此先排列金额1，再排列金额2的，不会重复
 * 例如dp[3]
 * 3=1+1+1;
 * 3=1+2;不会重复
 */  
  public int change(int amount, int[] coins) {
    int[] dp=new int[amount+1];
    dp[0]=1;
       for (int coin:coins){
           for (int i = coin; i <=amount ; i++) {
               dp[i]+=dp[i-coin];
           }
       }
        return dp[amount];
    }

139. 单词拆分

    public boolean wordBreak(String s, List<String> wordDict) {
        int len=s.length();
        boolean[] dp=new boolean[len+1];
        dp[0]=true;//包啥都不装
        for (int i = 1; i < len+1; i++) {//i代表现在遍历到的长度
            for(String word:wordDict){
                int wordLen=word.length();//物品的长度
                if (i>=wordLen && word.equals(s.substring(i-wordLen,i))){
                    //背包大小>=物品大小
                    dp[i]=dp[i]||dp[i-wordLen];//选择装包还是不装(装的前提是前i-len个元素匹配上了)
                }
            }
 
        }
        return dp[len];
    }