代码随想录day43|1049. 最后一块石头的重量 II 、494. 目标和 、474.一和零

1049. 最后一块石头的重量 II

解题思路：将所有的石头分成两堆近似相等的石头堆，那么他们向撞的话，一定就是最小的的了，也转变成为了01背包问题

dp[j]:重量为j的背包,最多可以北最大重量为dp[j]

递推公式：dp[j] = max(dp[j],dp[j-stones[j]]+stones[j]]

dp初始化：dp[0]=0,其余也是初始成0

遍历顺序：递减顺序

#define MAX(a, b) ((a) > (b) ? (a) : (b))
int getSum(int* stones, int stonesSize){
    int sum = 0;
    
    int i;
    for(i = 0; i < stonesSize; i++){
        sum += stones[i];
    }
    return sum;
}
int lastStoneWeightII(int* stones, int stonesSize) {
    int sum = getSum(stones, stonesSize);
    int target = sum / 2;
    int i , j;

    int* dp = (int*)malloc(sizeof(int) * (target + 1));
    memset(dp, 0, sizeof(int) * (target + 1));
    for(j = stones[0]; j <= target; ++j){
        dp[j] = stones[0];
    }

    for(i = 1; i < stonesSize; ++i){
        for(j = target; j >= stones[i]; --j){
            dp[j] = MAX(dp[j],dp[j - stones[i]] + stones[i]);
        }
    }
    return sum - dp[target] - dp[target];

}

  为什么要这样初始化

 for(j = stones[0]; j <= target; ++j){
        dp[j] = stones[0];
    }

——这样初始化的原因是，其实已经将物品0遍历了一遍，所以下面两层循环中，第一层的for就从1开始了，而不是从0开始 

494. 目标和

解题思路：分成两部分，一部分是加法，一种是减法，这样就转化成01背包问题

设加法的总和为x,则减法为sum-x,target = x-(sum-x)

所以x= (target+sum)/2  也就说背包的容量为x

dp[i]:填满容量为j的背包，有dp[j]种情况

递推公式：这里其实和路径总和一样，是一种累加的方法，当容量为1的时候，要凑齐容量5的话，那么就有dp[4]种情况

所以递推公式：dp[j]+= dp[j-nums[i]]

初始化：dp[0] = 1

直接带入计算，在数组[0]中， x=(target+sum)/2,那么x=0，那么dp[0]=1,因为零的的前面不管是什么符号，都是一样的意义，所以说，填满容量为0的背包，都有一种情况

遍历顺序：先物品再背包

int getSum(int* nums, int numsSize){
    int sum = 0, i;
    for(i = 0; i < numsSize; i++){
        sum += nums[i];
    }
    return sum;
}
int findTargetSumWays(int* nums, int numsSize, int target) {  
    int sum = getSum(nums, numsSize);  
    int diff = sum - target;  
      
    if (diff < 0 || diff % 2 != 0) {  
        return 0;  
    }  
    int bagSize = diff / 2;  
     
    int* dp = (int*)malloc(sizeof(int) * (bagSize + 1));  
     
    memset(dp, 0, sizeof(int) * (bagSize + 1));  
      
    dp[0] = 1;
  
    for (int i = 0; i < numsSize; ++i) {
        for (int j = bagSize; j >= nums[i]; --j) { 
            dp[j] += dp[j - nums[i]]; 
        }  
    }  
   
   
    return dp[bagSize];  
}

474. 一和零

dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。

dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。

dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。

然后我们在遍历的过程中，取dp[i][j]的最大值。

所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

此时大家可以回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

对比一下就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。

dp数组初始化：01背包的dp数组初始化为0就可以。

因为物品价值不会是负数，初始为0，保证递推的时候dp[i][j]不会被初始值覆盖。

遍历顺序：外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历！

#define max(a, b) ((a) > (b) ? (a) : (b))

int findMaxForm(char** strs, int strsSize, int m, int n) {
    int dp[m + 1][n + 1];
    memset(dp, 0, sizeof (int ) * (m + 1) * (n + 1));
    for(int i = 0; i < strsSize; i++){
        // 统计0和1的数量
        int count0 = 0;
        int count1 = 0;
        char *str = strs[i];
        while (*str != '\0'){
            if(*str == '0'){
                count0++;
            } else{
                count1++;
            }
            str++;
        }
        for(int j = m; j >= count0; j--){
            for(int k = n; k >= count1; k--){
                dp[j][k] = max(dp[j][k], dp[j - count0][k - count1] + 1);
            }
        }
    }
    return dp[m][n];
}