LeetCode刷题day23~24——动态规划-优快云博客

本文链接：https://blog.youkuaiyun.com/Screaming_Queen/article/details/144411292

LeetCode刷题day23~24——动态规划

- 0-1背包问题

0-1背包问题

46. 携带研究材料（第六期模拟笔试）

(https://kamacoder.com/problempage.php?pid=1046)

题目描述

小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的空间，并且具有不同的价值。

小明的行李空间为 N，问小明应该如何抉择，才能携带最大价值的研究材料，每种研究材料只能选择一次，并且只有选与不选两种选择，不能进行切割。

输入描述

第一行包含两个正整数，第一个整数 M 代表研究材料的种类，第二个正整数 N，代表小明的行李空间。

第二行包含 M 个正整数，代表每种研究材料的所占空间。

第三行包含 M 个正整数，代表每种研究材料的价值。

输出描述

输出一个整数，代表小明能够携带的研究材料的最大价值。

输入示例

6 1
2 2 3 1 5 2
2 3 1 5 4 3

输出示例

提示信息

小明能够携带 6 种研究材料，但是行李空间只有 1，而占用空间为 1 的研究材料价值为 5，所以最终答案输出 5。

数据范围：
1 <= N <= 5000
1 <= M <= 5000
研究材料占用空间和价值都小于等于 1000

分析：

今天开始学习0-1背包问题。关注的有三个数组，weight，value，dp。有m件物品，n的空间

动态规划定义：dp[i][j]是背包空间为j时，在第0~i件物品中任选物品，所能得到的最大价值
子问题：这是个二维数组，子问题是我们首先初始化的内容。此二维数组：横向是0~n, 纵向是物品0~m;

dp[i][0]=0,dp[0][weight[0]]=value[0] (from weight[0] to n)
动态规划方程：dp[i][j] = max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]),就是上看，斜看。斜看的理解是：这件东西就是确定要放进去，看一下放进去后剩的空间，这个剩的空间的最大价值；上看：就是不放。
怎么确定放还是不放？用现在的j and weight[i]比较大小，放得进就放，放不进不放。

#include <iostream>
#include <algorithm>
#include <set>
#include <string>
#include <vector>
using namespace std;

int main() {
    int m,n;
    cin>>m>>n;
    vector<int> weight(m);
    vector<int> value(m);
    for(int i=0;i<m;i++)
        cin>>weight[i];
    for(int i=0;i<m;i++)
        cin>>value[i];
    vector<vector<int>> dp(m,vector<int>(n+1,0));
    //init
    for(int i=weight[0];i<=n;i++) {
        dp[0][i]=value[0];
    }
    for(int i=1;i<m;i++) {
        for(int j=1;j<=n;j++) {
            if(j-weight[i]<0)
                dp[i][j]=dp[i-1][j];
            else
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);
        }
    }
    cout<<dp[m-1][n]<<endl;
    return 0;
}

416. 分割等和子集

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

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

示例 2：

输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

提示：

1 <= nums.length <= 200
1 <= nums[i] <= 100

分析：

首先排除两种情况：长度<=1，累加和为奇数。然后就开始动规了。

这个和背包问题的不同就是，没有规定价值，那我们直接把weight看成价值即可。其余的就不说了，上一题有写。
动态规划方程：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]);

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        if (sum % 2 != 0 || nums.size() <= 1)
            return false;
        sum /= 2;
        vector<vector<int>> dp(nums.size(), vector<int>(sum + 1, 0));
        for (int i = nums[0]; i <= sum; i++) {
            dp[0][i] = nums[0];
        }
        for (int i = 1; i < nums.size(); i++) {
            for (int j = 1; j <= sum; j++) {
                if (j - nums[i] < 0)
                    dp[i][j] = dp[i - 1][j];
                else
                    dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]);
            }
        }
        return dp[nums.size() - 1][sum] == sum ? true : false;
    }
};

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

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

示例 1：

输入：stones = [2,7,4,1,8,1]
输出：1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

示例 2：

输入：stones = [31,26,33,21,40]
输出：5

提示：

1 <= stones.length <= 30
1 <= stones[i] <= 100

分析：

我想到了其实就是把石头分成两堆，两堆差就是我们要求的值，而且需要让差尽可能小。但是始终没想到最后一步，原来这个就跟分割等和子集一样，只是需要把最后的结果处理一下而已，昨天看到这题觉得有点难，直接溜了。现在做完之后发现，好像也就这样。给我一个启示，遇到看似再难的题，坚持一下。

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum=0;
        for(int i=0;i<stones.size();i++) {
            sum+=stones[i];
        }
        int half = sum/2;
        vector<vector<int>> dp(stones.size(), vector<int>(half+1,0));
        for(int i=0;i<stones.size();i++)
            dp[i][0] = 0;
        for(int j=stones[0];j<=half;j++)
            dp[0][j] = stones[0];
        for(int i=1;i<stones.size();i++)
            for(int j=1;j<=half;j++) {
                if(j<stones[i])
                    dp[i][j] = dp[i-1][j];
                else
                    dp[i][j] = max(dp[i-1][j],dp[i-1][j-stones[i]]+stones[i]);
            }
        return sum-2*dp[stones.size()-1][half];//就是这里改动了一下
            
    }
};

494. 目标和

给你一个非负整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

示例 1：

输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3

示例 2：

输入：nums = [1], target = 1
输出：1

提示：

1 <= nums.length <= 20
0 <= nums[i] <= 1000
0 <= sum(nums[i]) <= 1000
-1000 <= target <= 1000

分析：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++)
            sum += nums[i];
        int neg = sum - target;
        if (neg < 0 || neg % 2 != 0)
            return 0;
        neg /= 2;
        vector<vector<int>> dp(nums.size(), vector<int>(neg + 1, 0));
        dp[0][0] =
            1; // base case, sum=0 is always 1 way (not choosing anything)
        if (nums[0] <= neg)
            dp[0][nums[0]] = 1; // base case, using first element
        int numZero = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == 0)
                numZero++;
            dp[i][0] = (int)pow(2.0, numZero);
        }

        for (int i = 1; i < nums.size(); i++)
            for (int j = 1; j <= neg; j++) {
                if (j < nums[i])
                    dp[i][j] = dp[i - 1][j];
                else
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];
            }
        return dp[nums.size() - 1][neg];
    }
};

474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集。

示例 1：

输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

示例 2：

输入：strs = ["10", "0", "1"], m = 1, n = 1
输出：2
解释：最大的子集是 {"0", "1"} ，所以答案是 2 。

提示：

1 <= strs.length <= 600
1 <= strs[i].length <= 100
strs[i] 仅由 '0' 和 '1' 组成
1 <= m, n <= 100

分析：

难，程序员何苦为难程序员。现在的物品是每一个字符串数组，dp的横纵坐标分别是m,n。

动态规划定义：dp[i][j]表示最多i个0，j个1具有的最大子集个数。
子问题：dp[i][j]=0全部初始化为0；
动态规划方程：dp[i][j]=max(dp[i][j],dp[i-numZero][j-numZero]+1),显然第一个参数是本物品不装进去，第二个参数是本物品装进去之后，剩余的空间能放多少。
本次遍历顺序跟之前的不一样，其实应该是三维数组，但是降维之后，物品从头遍历；容量从后往当前遍历

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for (int k = 0; k < strs.size(); k++) {//物品在最外层
            string s = strs[k];
            int numZero = 0, numOne = 0;
            for (int j = 0; j < s.size(); j++) {
                if (s[j] == '0')
                    numZero++;
                else if (s[j] == '1')
                    numOne++;
            }//统计本字符串0、1的数量
            for (int i = m; i >= numZero; i--) {//从后往当前遍历，注意，这里是滚动数组，相当于降维处理，只能从后往前
                for (int j = n; j >= numOne; j--) {
                    dp[i][j] = max(dp[i][j], dp[i - numZero][j - numOne] + 1);//max(不放，放+1)
                }
            }
        }
        return dp[m][n];
    }
};