代码随想录：动态规划_02背包问题

weixin_51503393

已于 2024-07-01 23:53:18 修改

阅读量571

点赞数 29

文章标签：动态规划算法 c++

于 2024-07-01 23:50:19 首次发布

本文链接：https://blog.csdn.net/weixin_51503393/article/details/140062199

版权

46. 携带研究材料

小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的空间，并且具有不同的价值。
小明的行李空间为 N，问小明应该如何抉择，才能携带最大价值的研究材料，每种研究材料只能选择一次，并且只有选与不选两种选择，不能进行切割。

输入描述

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

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

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

输出描述

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

二维数组

#include<bits/stdc++.h>
using namespace std;
int main(){
    int m,n;
    cin>>m>>n;
    vector<int> weight(m),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));//dp表示0-m个材料放入空间为n的背包的最大价值
    for(int i = weight[0];i <= n;i++){
        dp[0][i] = value[0];
    }
    for(int i = 1;i < m;i++){//遍历物品
        for(int j = 0;j <= n;j++){//遍历背包
            if(j < weight[i])
                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];
    return 0;
}

滚动数组

#include<bits/stdc++.h>
using namespace std;
int main(){
    int m,n;
    cin>>m>>n;
    vector<int> weight(m),value(m);
    for(int i = 0;i < m;i++){
        cin>>weight[i];
    }
    for(int i = 0;i < m;i++){
        cin>>value[i];
    }
    vector<int> dp(n+1,0);//dp表示空间为n的背包的最大价值
    for(int i = weight[0];i <= n;i++){
        dp[i] = value[0];
    }
    for(int i = 1;i < m;i++){//遍历物品
        for(int j = n;j >= 0;j--){//反向遍历背包，避免重复添加物品
            if(j >= weight[i])
                dp[j] = max(dp[j],dp[j - weight[i]] + value[i]);
        }
    }
    cout<<dp[n];
    return 0;
}

416. 分割等和子集

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

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)
            return false;
        int target = sum/2;
        vector<int> dp(10001,0);//dp表示空间为j的背包装的最大价值
        for(int i = 0;i < nums.size();i++){//遍历物品
            for(int j = target;j >= nums[i];j--){//遍历背包
                dp[j] = max(dp[j],dp[j - nums[i]] + nums[i]);
            }
        }
        if (dp[target] == target) 
            return true;
        return false;
    }
};

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

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。
每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = accumulate(stones.begin(),stones.end(),0);
        int target = sum / 2;
        vector<int> dp(target+1,0);
        for(int i = 0;i < stones.size();i++){
            for(int j = target;j >= stones[i];j--){
                dp[j] = max(dp[j],dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - 2*dp[target];
    }
};

494. 目标和

给你一个非负整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个表达式：
例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同表达式的数目。

动态规划

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = accumulate(nums.begin(),nums.end(),0);
        if(abs(target) > sum)
            return 0;
        if ((target + sum) % 2 == 1)
            return 0;
        int bagSize = (target + sum) / 2;
        vector<int> dp(bagSize+1,0);
        dp[0] = 1;
        for(int i = 0;i < nums.size();i++){
            for(int j = bagSize;j >= nums[i];j--){
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[bagSize];
    }
};

回溯

class Solution {
public:
    int cnt = 0;
    void backtracking(vector<int>& nums,int sum,int target,int i){
        if(i == nums.size()){
            if(sum == target)
                cnt++;
            return;
        }
        backtracking(nums,sum + nums[i],target,i+1);
        backtracking(nums,sum - nums[i],target,i+1);
    }
    int findTargetSumWays(vector<int>& nums, int target) {
        backtracking(nums,0,target,0);
        return cnt;
    }
};

474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。
如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集。

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));//最多有i个0和j个1的strs的最大子集的大小为dp[i][j]
        for(string s:strs){
            int one = 0,zero = 0;
            for(char c:s){
                if(c == '0')
                    zero++;
                else
                    one++;
            }
            for(int i = m;i >= zero;i--){
                for(int j = n;j >= one;j--){
                    dp[i][j] = max(dp[i][j],dp[i - zero][j - one] + 1);
                }
            }
        }
        return dp[m][n];
    }
};

完全背包（物品使用次数不限）

52. 携带研究材料

#include<bits/stdc++.h>
using namespace std;
int main(){
    int n,v;
    cin >> n >> v;
    vector<vector<int>> things(n,vector<int>(2,0));
    vector<int> dp(v+1, 0);
    for(int i = 0; i < n; i++){
        cin >> things[i][0] >> things[i][1];
    }
    for(int i = 0;i < n;i++){
        for(int j = things[i][0];j <= v;j++){
            dp[j] = max(dp[j],dp[j - things[i][0]] + things[i][1]);
        }
    }
    cout << dp[v];
    return 0;
}

518. 零钱兑换 II

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。
请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。
假设每一种面额的硬币有无限个。

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount+1,0);
        dp[0] = 1;
        for(int i = 0; i < coins.size(); i++){//先遍历物品
            for(int j = coins[i]; j <= amount; j++){
                dp[j] += dp[j - coins[i]];
            }
        }
        return dp[amount];
    }
};

377. 组合总和 Ⅳ

给你一个由不同整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target+1,0);
        dp[0] = 1;
        for(int j = 0; j <= target; j++){//先遍历背包
            for(int i = 0; i < nums.size(); i++){
                if(j >= nums[i] && dp[j] < INT_MAX - dp[j - nums[i]])
                    dp[j] += dp[j - nums[i]];
            }
        }
        return dp[target];
    }
};

57. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬至多m (1 <= m < n)个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。

#include<bits/stdc++.h>
using namespace std;
int main(){
    int n,m;
    cin >> n >> m;
    vector<int> dp(n+1,0);//爬到有i个台阶的楼顶，有dp[i]种方法
    dp[0] = 1;
    for(int i = 1;i <= n;i++){
        for(int j = 1;j <= m;j++){
            if(i >= j)
                dp[i] += dp[i - j];
        }
    }
    cout << dp[n];
    return 0;
}

322. 零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1 。

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount+1,INT_MAX);//dp[i]表示凑成i得最少硬币个数
        dp[0] = 0;
        for(int i = 0;i < coins.size();i++){
            for(int j = coins[i];j <= amount;j++){
                if (dp[j - coins[i]] != INT_MAX) {
                    dp[j] = min(dp[j],dp[j - coins[i]] + 1);
                }
            }
        }
        if (dp[amount] == INT_MAX) return -1;
        return dp[amount];
    }
};

279. 完全平方数

给你一个整数 n ，返回和为 n 的完全平方数的最少数量。
完全平方数是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n+1,INT_MAX);//dp表示和为i的完全平方数的最少数量
        dp[0] = 0;
        for(int i = 0;i*i <= n;i++){//遍历物品
            for(int j = i*i;j <= n;j++){//遍历背包
                if(dp[j - i] != INT_MAX)
                    dp[j] = min(dp[j],dp[j - i*i] + 1);
            }
        }
        return dp[n];
    }
};

多重背包问题

56. 携带矿石资源

你是一名宇航员，即将前往一个遥远的行星。在这个行星上，有许多不同类型的矿石资源，每种矿石都有不同的重要性和价值。你需要选择哪些矿石带回地球，但你的宇航舱有一定的容量限制。
给定一个宇航舱，最大容量为 C。现在有 N 种不同类型的矿石，每种矿石有一个重量 w[i]，一个价值 v[i]，以及最多 k[i] 个可用。不同类型的矿石在地球上的市场价值不同。你需要计算如何在不超过宇航舱容量的情况下，最大化你所能获取的总价值。

#include<iostream>
#include<vector>
using namespace std;
int main() {
    int bagWeight,n;
    cin >> bagWeight >> n;
    vector<int> weight(n, 0);
    vector<int> value(n, 0);
    vector<int> nums(n, 0);
    for (int i = 0; i < n; i++) cin >> weight[i];
    for (int i = 0; i < n; i++) cin >> value[i];
    for (int i = 0; i < n; i++) cin >> nums[i];
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < n; i++) { // 遍历物品
        for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
            // 以上为01背包，然后加一个遍历个数
            for (int k = 1; k <= nums[i] && (j - k * weight[i]) >= 0; k++) { // 遍历个
                dp[j] = max(dp[j], dp[j - k * weight[i]] + k * value[i]);
            }
        }
    }
    cout << dp[bagWeight] << endl;
}

背包问题总结

问能否能装满背包（或者最多装多少）：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]); 

问装满背包有几种方法：dp[j] += dp[j - nums[i]];

问背包装满最大价值：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]); 

问装满背包所有物品的最小个数：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);

weixin_51503393

关注

29
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
代码随想录：动态规划_02背包问题

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x
复制链接

扫一扫