【代码随想录】【算法训练营】【第42天】 [1049]最后一块石头的重量II [494]目标和 [474]一和零

前言

思路及算法思维，指路 代码随想录。
题目来自 LeetCode。

day 42，周二，坚持一下~

题目详情

[1049] 最后一块石头的重量II

题目描述

1049 最后一块石头的重量II

解题思路

前提：最多只会剩下一块 石头，求此石头最小的可能重量
思路：将原数组分为两个子集，使其重量和最相近，此时剩余重量最小。0-1背包问题，动态规划。
重点：问题转化为0-1背包问题，dp数组的定义、初始化及推导公式。

代码实现

C语言

dp[i][j]

分为两个子集，使其重量和最相近，此时剩余重量最小
dp[i][j]: 在[0, i]中, 不大于重量j的石头重量和
dp[i][j] = max(dp[i-1][j], dp[i-1][j-stones[i]]+stones[i])

int sumFun(int *stones, int stonesSize)
{
    int sum = 0;
    for (int i = 0; i < stonesSize; i++) {
        sum += stones[i];
    }
    return sum;
}

int maxFun(int p1, int p2)
{
    return p1 > p2 ? p1 : p2;
}

int lastStoneWeightII(int* stones, int stonesSize) {
    int totalSum = sumFun(stones, stonesSize);
    int target = totalSum / 2;
    int dp[stonesSize][target + 1];
    // 初始化dp数组
    for (int j = 0; j <= target; j++) {
        if (j < stones[0]) {
            dp[0][j] = 0;
        } else {
            dp[0][j] = stones[0];
        }
    }
    for (int i = 1; i < stonesSize; i++) {
        for (int j = 0; j <= target; j++) {
            if (j < stones[i]) {
                dp[i][j] = dp[i - 1][j];
            } else {
                dp[i][j] = maxFun(dp[i - 1][j], dp[i - 1][j -stones[i]] + stones[i]);
            }
        }
    }
    return ((totalSum - dp[stonesSize - 1][target]) - dp[stonesSize - 1][target]);
}

dp[j]

分为两个子集，使其重量和最相近，此时剩余重量最小
压缩dp[i][j]为dp[j]: 在[0, i]中, 不大于重量j的石头重量和
dp[j] = max(dp[j], dp[j-stones[i]]+stones[i])

int sumFun(int *stones, int stonesSize)
{
    int sum = 0;
    for (int i = 0; i < stonesSize; i++) {
        sum += stones[i];
    }
    return sum;
}

int maxFun(int p1, int p2)
{
    return p1 > p2 ? p1 : p2;
}

int lastStoneWeightII(int* stones, int stonesSize) {
    int totalSum = sumFun(stones, stonesSize);
    int target = totalSum / 2;
    int dp[target + 1];
    // 初始化dp数组
    for (int j = 0; j <= target; j++) {
        dp[j] = 0;
    }
    // 遍历石头，从大到小遍历target
    for (int i = 0; i < stonesSize; i++) {
        for (int j = target; j >= stones[i]; j--) {
            dp[j] = maxFun(dp[j], dp[j -stones[i]] + stones[i]);
        }
    }
    return ((totalSum - dp[target]) - dp[target]);
}

[494] 目标和

题目描述

494 目标和

解题思路

前提：运算结果等于 target 的数量，target = left - right ，sum = left + right
思路：推到可知 left = (target + sum) / 2，转化为数组[0, i]中数值之和恰好等于left的数目，0-1背包问题 dp[i][j] = dp[i - 1][j] + dp[i - 1][j - num[i]]
重点：问题的转化，dp[i][j] 数组的初始化，以及公式推导

代码实现

C语言

dp[i][j]

dp[i][j]数组初始化，是个大问题！！！
关注数组全0情况~

// target = left - right
// sum = left + right
// left = (target + sum) / 2
// dp[i][j]: [0, i]中数值之和q恰好=left的数目
// dp[i][j] = dp[i - 1][j] + dp[i - 1][j - num[i]]

int sumFun(int *nums, int numsSize)
{
    int totalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        totalSum += nums[i];
    }
    return totalSum;
}

int findTargetSumWays(int* nums, int numsSize, int target) {
    int sum = sumFun(nums, numsSize);
    // 考虑target为负数的情况
    if ((sum < target) || ((sum + target) < 0) || ((target + sum) % 2 == 1)) {
        return 0;
    }
    int left = (target + sum) / 2;
    int dp[numsSize][left + 1];
    // dp初始化
    dp[0][0] = 1;
    for (int j = 0; j <= left; j++) {
        dp[0][j] = 0;
        if (j == 0) {
            dp[0][0] = 1;
        }
        if (j == nums[0]) {
            dp[0][j] += dp[0][j - nums[0]];
        }
    }
    // 遍历数组元素及left大小
    for (int i = 1; i < numsSize; i++) {
        for(int j = 0; j <= left; j++) {
            dp[i][j] = dp[i - 1][j];
            if (j >= nums[i]) {
                dp[i][j] += dp[i - 1][j - nums[i]];
            }
            printf("%d ", dp[i][j]);
        }
        printf("\n");
    }
    return dp[numsSize - 1][left];
}

dp[j]

// target = left - right
// sum = left + right
// right = (sum - target) / 2, 这样可以避免考虑target为很大负值的特殊情况
// 压缩为滚动一维数组dp[j]: [0, i]中数值之和恰好=right的数目
// dp[j] = dp[j] + dp[j - num[i]]

int sumFun(int *nums, int numsSize)
{
    int totalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        totalSum += nums[i];
    }
    return totalSum;
}

int findTargetSumWays(int* nums, int numsSize, int target) {
    int sum = sumFun(nums, numsSize);
    if ((sum < target) || ((sum - target) % 2 == 1)) {
        return 0;
    }
    int right = (sum - target) / 2;
    int dp[right + 1];
    // dp初始化
    dp[0] = 1;
    for (int j = 1; j <= right; j++) {
        dp[j] = 0;
    }
    // 遍历数组元素, 从大到小遍历right大小
    for (int i = 0; i < numsSize; i++) {
        for(int j = right; j >= nums[i]; j--) {
            if (j >= nums[i]) {
                dp[j] += dp[j - nums[i]];
            }
        }
    }
    return dp[right];
}

[474] 一和零

题目描述

474 一和零

解题思路

前提：虽然有“最多”的字眼，但是对于数组strs来说，还是最多只取一个元素，所以还是0-1背包问题
思路：该背包的维度是两个，str的遍历另算，所以非滚动数组是个三维数组，为了赋值方便，直接使用滚动二维数组实现
重点：问题的区分，dp[i][j] 数组的初始化，以及公式推导

代码实现

C语言

滚动数组dp[i][j]，背包的维度是两个，str的遍历另算

// 此处的dp[i][j]是滚动数组，背包的维度是两个，str的遍历另算
// dp[i][j]: 最多有i个0, j个1的strs的子集的最大长度
// dp[i][j] = max(dp[i][j], dp[i-zeroNum][j-oneNum]+1)

int maxFun(int p1, int p2)
{
    return p1 > p2 ? p1 : p2;
}

int findMaxForm(char** strs, int strsSize, int m, int n) {
    int dp[m + 1][n + 1];
    // 初始化dp
    for (int i = 0; i <= m; i++) {
        for (int j = 0; j <= n; j++) {
            dp[i][j] = 0;
        }
    }
    // 遍历strs数组, 并且从大到小遍历m和n两个维度的背包
    for (int s = 0; s < strsSize; s++) {
        // 计算该字符串的0和1个数
        int zeroNum = 0;
        int oneNum = 0;
        for (int k = 0; k < strlen(strs[s]); k++) {
            if (strs[s][k] == '0') {
                zeroNum++;
            } else {
                oneNum++;
            }
        }
        // 0-1背包, 从大到小遍历m和n两个维度的背包
        for (int i = m; i >= zeroNum; i--) {
            for (int j = n; j >= oneNum; j--) {
                dp[i][j] = maxFun(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
            }
        }
    }
    return dp[m][n];
}

今日收获

1. 0-1背包问题：问题的转化与识别，dp数组的初始化、dp公式推导