dp_day3(01背包)

本文详细介绍了01背包问题的定义、动态规划解法,包括递推公式、初始化步骤和遍历顺序,以及通过纯C++代码示例展示。还探讨了几个使用01背包的典型应用问题,如分割等和子集、最后一块石头的重量2和目标和问题的求解。
摘要由CSDN通过智能技术生成

目录

01背包概述:

01背包是经典的动态规划的解法

完整的纯01背包代码

几道01背包的应用题

1.分割等和子集

1,回溯法

2,dp法

2.最后一块石头的重量2

3.目标和

1,回溯法

2.dp法


01背包概述:

01背包问题为有n种物品,每种物品只有一个,每个物品都有自己的价值和重量,有一个最多能放重量为m的背包,问:这个背包最多能装多少价值的物品.

首先,这个问题不能用简单的贪心解决,因为如果仅仅每次放价值最大的物品,因为能放的最大重量有限,放多个价值较小但重量较轻的物品可能会更优.

01背包是经典的动态规划的解法

                 w        v

物品0        1        15

物品1        3        20

物品2        4        30

1,dp[j]含义:容量为j的背包所能容纳的最大价值

2.递推公式:再放i物品的时候有放和不放两种状态

不放i物品:包里价值为之前的dp[j]

放i物品:包里价值为dp[j-weight[i]]+value[i],相当于放了i物品后除去i物品空间的背包能装的最大价值加上i物品的价值(前提是放的下i,要求是j>=weight[i])

两种情况的最大值就是dp[j]的新值.故递推公式为dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);

3.初始化:物品的价值为整数,全都赋为0即可

4.遍历顺序:物品从前向后遍历即可,而背包容量要从后向前遍历,因为从前向后遍历的话:如果背包容量够大,它会装下多个物品0,这并不是我们想要的

5.举例推导dp数组

由上例

放物品0 :      0                  1                  2                   3                     4

015151515

放物品1  :    

01515  2035

放物品2:  

015152035

自己推导一遍就会明白从后向前遍历背包容量,dp[j-weight[i]]都是之前的状态,还未更新,所以不会重复放某个物品

完整的纯01背包代码

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int weight[5005],value[5005],dp[5005]={0};//dp[j]:容量为j的背包所能装的最大价值
    int n,m;
    cin>>m>>n;
    for(int i=0;i<m;i++)cin>>weight[i];
    for(int i=0;i<m;i++)cin>>value[i];
    //for(int j=weight[0];j<=n;j++)
    //dp[0][j]=value[0];
    for(int i=0;i<m;i++)
    {
        for(int j=n;j>=weight[i];j--)
        {
            dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);
        }
    }
    cout<<dp[n];
    return 0;
}

几道01背包的应用题

分割等和子集

1.分割等和子集

1,回溯法

暴力方法当然是回溯法:枚举每种组合,看是否有组合的和等于所有元素总和的一半,非常容易可以知道如果总和为奇数,就不可能凑出等和的两部分,由此剪枝.但还是超时了.

class Solution {
public:
    int tol=0,sum=0,flag=0;
    void dfs(int startindex,vector<int>&nums)
    {
        if(sum==tol/2)
        {
            flag=1;
            return; 
        }
        for(int i=startindex;i<nums.size()&&flag==0;i++)
        {
            sum+=nums[i];
            dfs(i+1,nums);
            sum-=nums[i];
        }
    }
    bool canPartition(vector<int>& nums) {
        for(int i=0;i<nums.size();i++)tol+=nums[i];
        if(tol%2!=0)return false;
        else
        {
            dfs(0,nums);
            if(flag)
            return true;
            else 
            return false;
        }
    }
};

2,dp法

01背包的解法就是容量为总和一半的背包可不可以恰好装满来判定是否可以分成和相等的两部分

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

最后一块石头的重量2

2.最后一块石头的重量2

这题与上一题类似,但这一题求的是容量为总重量一半的背包最多能装多少,使两堆石头差别尽可能小

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int dp[1505]={0},tol=0;
        for(int i=0;i<stones.size();i++)tol+=stones[i];
        for(int i=0;i<stones.size();i++)
        {
            for(int j=tol/2;j>=stones[i];j--)
            {
                dp[j]=max(dp[j],dp[j-stones[i]]+stones[i]);
            }
        }
        int mid=tol/2;
        return tol-2*dp[mid];
    }
};

目标和

3.目标和

1,回溯法

class Solution {
public:
    int sum=0,cnt=0;
    void dfs(int startindex,vector<int>&nums,int s)
    {
        if(sum==s)
        {
            cnt++;
        }
        for(int i=startindex;i<nums.size()&&sum+nums[i]<=s;i++)
        {
            sum+=nums[i];
            dfs(i+1,nums,s);
            sum-=nums[i];
        }
    }
    int findTargetSumWays(vector<int>& nums, int target) {
        int tol=0;
        for(int i=0;i<nums.size();i++)tol+=nums[i];
        if(target>tol)return 0;
        if((target+tol)%2)return 0;
        int s=(target+tol)/2;
        sort(nums.begin(),nums.end());//方便剪枝,sum+nums[i]<=s
        dfs(0,nums,s);
        return cnt;
    }
};

2.dp法

这题可以转化成装满容量为j的背包有多少种方法

把数字分为总和分别为a,b的两堆

sum=a+b,target=a-b,

所以sum+target=2a,题目就转化成有多少个组合的总和为a,即装满容量为a的背包有多少种方法

这与前两题不同

1,dp[j]含义:装满容量为j的背包有多少种方法

2,递推公式:dp[j]+=dp[j-weight[i]]因为要装下i物体,就要找装满容量为j-weight[i]的背包的方法数是多少,所有的dp[j]累加起来即可.

3.初始化.dp[0]=1;其他的为0,因为用一个背包装一个物体恰好装满是加的dp[0],这算一种方法

4,遍历顺序,与01背包相同,物品从前向后,背包从后向前

5.举例推导dp数组

nums = [1,1,1,1,1], target = 3

s=(5+3)/2=4;

第一个数1

11000

第二个数1

12100

第三个数1

13310

第四个数1

14641

第五个数1

1510105

所以答案为dp[4]=5;

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

  • 63
    点赞
  • 38
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值