背包九讲问题

最新推荐文章于 2020-05-30 11:15:01 发布
最新推荐文章于 2020-05-30 11:15:01 发布
阅读量214 收藏
点赞数 1
分类专栏： 基础理论知识 victor的DP专练 文章标签： DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gtgym321/article/details/90421592
版权

ps：dp全部初始化为0,指最大为j时的最大价值。
将dp初始化为-inf,dp[0] = 1,为容量为j的最大价值

01背包

#include<bits/stdc++.h>
using namespace std;
int dp[1001];
int v[1010],w[1010];
int main(){
    int n , m;
    cin >> n >> m;
    dp[0][0] = 0;
    
    for(int i = 1; i <= n ; i ++){
        cin >> v[i] >> w[i];
    }
    for(int i = 1; i <= n ; i++){
        for(int j = 0; j <= m ; j ++ )
        {
            //dp[i][j] = dp[i-1][j];
            if(j >= v[i])
            dp[j] = max(dp[j],dp[j-v[i]] + w[i]);
        }
    }
  //  int res= 0;
   // for(int i = 0 ;i <= m ; i++) {
    //    res = max(res , dp[n][i]);
    //}
    cout << f[m] << endl;
    return 0;
}

完全背包

#include<bits/stdc++.h>
using namespace std;
int dp[1001];
int v[1010],w[1010];
int main(){
    int n , m;
    cin >> n >> m;
   // dp[0][0] = 0;
    
    for(int i = 1; i <= n ; i ++){
        cin >> v[i] >> w[i];
    }
    for(int i = 1; i <= n ; i++){
        for(int j = 0; j <= m ; j ++ )
        {
            //dp[i][j] = dp[i-1][j];
            if(j >= v[i])
            dp[j] = max(dp[j],dp[j-v[i]] + w[i]);
        }
    }
    int res= 0;
    for(int i = 0 ;i <= m ; i++) {
        res = max(res , dp[i]);
    }
    cout << res << endl;
    return 0;
}

多重背包（只能解决数据范围小的）

#include<bits/stdc++.h>
using namespace std;
int dp[1001];
int v[1010],w[1010],u[1010];
int main(){
    int n , m;
    cin >> n >> m;
   // dp[0][0] = 0;
    
    for(int i = 1; i <= n ; i ++){
        cin >> v[i] >> w[i] >> u[i];
    }
    for(int i = 1; i <= n ; i++){
        for(int j = m; j >= 0 ; j -- )
        {
            ///
            for(int k = 0; k <= u[i] && k * v[i] <= j ; k++)
            //dp[i][j] = dp[i-1][j];
            if(j >= v[i])
            dp[j] = max(dp[j],dp[j-k * v[i]] + k * w[i]);
        }
    }

    cout << dp[m] << endl;
    return 0;
}

多组背包2（二进制优化）

#include<bits/stdc++.h>
using namespace std;
const int maxn = 2010;
int dp[maxn];
int v,w,u;
struct node{
    int u , v;
}np;
vector<node> ve;
int main(){
    int n , m ;
    cin >> n >> m;
    for(int i = 1 ; i <= n ;i ++){
        cin >> v >> w >> u;
        for(int k = 1; k <= u ; k *= 2){
            u -= k;
            ve.push_back({k * v , k * w});
        }
        if(m > 0) ve.push_back({u * v , u * w});
    }
    for(auto nps : ve){
        for(int  i = m ; i >= nps.u; i --){
            dp[i] = max(dp[i],dp[i-nps.u] + nps.v);
        }
    }
    cout << dp[m] << endl;
    return 0 ;
}

多组背包究极版（滑稽）3*1e8硬是让我卡过去了

#include<bits/stdc++.h>
using namespace std;
//手动扩栈
#pragma comment(linker,"/STACK:102400000,102400000")


//~victor~Alexander 20:03:51
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
%:pragma GCC optimize("Ofast")
%:pragma GCC optimize("inline")
%:pragma GCC optimize("-fgcse")
%:pragma GCC optimize("-fgcse-lm")
%:pragma GCC optimize("-fipa-sra")
%:pragma GCC optimize("-ftree-pre")
%:pragma GCC optimize("-ftree-vrp")
%:pragma GCC optimize("-fpeephole2")
%:pragma GCC optimize("-ffast-math")
%:pragma GCC optimize("-fsched-spec")
%:pragma GCC optimize("unroll-loops")
%:pragma GCC optimize("-falign-jumps")
%:pragma GCC optimize("-falign-loops")
%:pragma GCC optimize("-falign-labels")
%:pragma GCC optimize("-fdevirtualize")
%:pragma GCC optimize("-fcaller-saves")
%:pragma GCC optimize("-fcrossjumping")
%:pragma GCC optimize("-fthread-jumps")
%:pragma GCC optimize("-funroll-loops")
%:pragma GCC optimize("-fwhole-program")
%:pragma GCC optimize("-freorder-blocks")
%:pragma GCC optimize("-fschedule-insns")
%:pragma GCC optimize("inline-functions")
%:pragma GCC optimize("-ftree-tail-merge")
%:pragma GCC optimize("-fschedule-insns2")
%:pragma GCC optimize("-fstrict-aliasing")
%:pragma GCC optimize("-fstrict-overflow")
%:pragma GCC optimize("-falign-functions")
%:pragma GCC optimize("-fcse-skip-blocks")
%:pragma GCC optimize("-fcse-follow-jumps")
%:pragma GCC optimize("-fsched-interblock")
%:pragma GCC optimize("-fpartial-inlining")
%:pragma GCC optimize("no-stack-protector")
%:pragma GCC optimize("-freorder-functions")
%:pragma GCC optimize("-findirect-inlining")
%:pragma GCC optimize("-fhoist-adjacent-loads")
%:pragma GCC optimize("-frerun-cse-after-loop")
%:pragma GCC optimize("inline-small-functions")
%:pragma GCC optimize("-finline-small-functions")
%:pragma GCC optimize("-ftree-switch-conversion")
%:pragma GCC optimize("-foptimize-sibling-calls")
%:pragma GCC optimize("-fexpensive-optimizations")
%:pragma GCC optimize("-funsafe-loop-optimizations")
%:pragma GCC optimize("inline-functions-called-once")
%:pragma GCC optimize("-fdelete-null-pointer-checks")

const int maxn = 20010;
int dp[maxn];
int v,w,u;
struct node{
    int u , v;
}np;
vector<node> ve;
int main(){
    int n , m ;
    ios::sync_with_stdio(false); cin.tie(0);cout.tie(0);
    cin >> n >> m;
    for(int i = 1 ; i <= n ;i ++){
        cin >> v >> w >> u;
        for(int k = 1; k <= u ; k *= 2){
            u -= k;
            ve.push_back({k * v , k * w});
        }
        if(m > 0) ve.push_back({u * v , u * w});
    }
    for(auto nps : ve){
        for(int  i = m ; i >= nps.u; i --){
            dp[i] = max(dp[i],dp[i-nps.u] + nps.v);
        }
    }
    cout << dp[m] << endl;
    return 0 ;
}

真正的究极版（单调队列 + 滚动数组）

混合背包问题
（转换成01和完全解决）

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1010;
struct node{
    int kind;
    int v ,w;
};
int n  , m ;
int v , w , k;
int dp[maxn];
int main(){
    cin >>  n >> m;
    vector<node> ve;
    for(int  i = 1; i <= n ; i++){
        cin >> v >> w >> k;
        if(k < 0) ve.push_back({-1,v,w});
        else if(k == 0) ve.push_back({0,v,w});
        else {
            for(int j = 1; j <= k ; j ++){
                k -= j ;
                ve.push_back({-1,j * v ,j * w });
                
            }
            if(k > 0) ve.push_back({-1,k * v , k * w});
        }
    }
    for(auto np : ve){
        if(np.kind == -1) {
            for(int j = m ; j >= np.v; j --){
                dp[j] = max(dp[j], dp[j -np.v ] + np.w);
            }
        }
        else {
            for(int j =np.v ; j <= m; j++){
                dp[j] = max(dp[j] , dp[j - np.v] + np.w);
            }
        }
    }
    cout << dp[m] << endl;
    return 0 ;
}

二维费用的背包问题

#include<bits/stdc++.h>
using namespace std;
//int u[1010],s[1010],w[1010];
int dp[1010][1010];
int main(){
    int n , v , m ;
    cin >> n >> v >> m;
  
    for(int i = 1; i <= n ; i++){
        int u , s , w;
        cin >> u >> s >> w;
        for(int j =  v ; j >= u ; j --){
            for(int k = m ; k >= s; k--){
                dp[j][k] = max(dp[j][k] , dp[j - u][k - s] + w);
            }
        }
    }
    cout << dp[v][m] << endl;
    return 0;
}

分组背包问题

#include<bits/stdc++.h>
using namespace std;
//vector<int> a[110];
int x[110],y[110];
int dp[110];
int main(){
    int n,m;
    cin >> n >> m;
    for(int i = 1;  i <= n ; i++){
        int t;
        cin >> t;
     //   int x,w;
        for(int k = 1 ; k <= t; k ++) 
                cin >> x[k] >> y[k];
        for(int j = m;j >=0; j -- ){
           
               for(int k = 1 ; k <= t; k ++) 
                if(j >= x[k])
                    dp[j] = max(dp[j],dp[j -x[k] ] + y[k]);
                
            
        }
    }
    cout << dp[m] << endl;
    return 0;
}

有依赖的背包问题

#include <bits/stdc++.h>
using namespace std;

const int maxn = 1010;
struct edge{
    int to , nxt , w, v;
}e[maxn << 1];
int n,m ;
int dp[maxn][maxn];
int v[maxn], w[maxn];
int tot;
int head[maxn];
void add_edge(int u , int v){
    // v
   // e[tot].w = w;
   // e[tot].v = x;
    e[tot].to = v;
    e[tot].nxt = head[u];
    head[u] = tot ++;
}

void dfs(int u){
    for(int i = head[u]; ~i ; i = e[i].nxt){
        int y = e[i].to;
        dfs(y);
        for(int j = m - v[u];j >= 0; j--){
            for(int k = 0; k <= j ; k ++){
                dp[u][j] = max(dp[u][j] , dp[u][j - k] + dp[y][k]);
            }
        }
    }
//cout << v[u] << endl;
    for(int  i = m; i >= v[u] ; i--){
        dp[u][i] = dp[u][i - v[u]] + w[u];
    }

    for(int i = 0 ; i < v[u];i ++){
        dp[u][i] = 0;
    }
}

int main(){
    memset(head,-1,sizeof head);
    cin >> n >> m;
    int root;
    for(int i = 1; i <= n ; i++){
        //v , w ,p 
        int p;
        cin >> v[i] >> w[i] >> p;
        if(p == -1) root = i;
        else 
        add_edge(p,i);
    }
    dfs(root);
    
    
    cout << dp[root][m] << endl;
    return 0;
}

背包问题求方案数

#include <bits/stdc++.h>
using namespace std;

const int maxn = 1010,mod = 1e9 + 7;
int n , m;
int v[maxn],w[maxn];
int dp[maxn],cnt[maxn];
const int inf = 9999999;

int main(){
	cin >> n >> m;
	cnt[0] = 1;
	for(int i  = 1; i <= m ; i++) dp[i] = -inf;
		for(int  i = 0; i < n ; i++){
			int v, w;
			cin >> v >> w;
			int s = 0;
			for(int  j = m ; j >= v; j --){
				s = 0;
				int t = max(dp[j] ,dp[j - v] + w);
				if(t == dp[j]) s += cnt[j];
				if(t == dp[j - v] + w ) s+= cnt[j - v];
				if(s >= mod) s-= mod;
				dp[j] = t;
				cnt[j] = s;

			}
		}

		int  maxx = 0;
		for(int i = 0 ;i <= m ; i++) maxx = max(maxx,dp[i]);
			int res = 0;
			for(int i = 0 ; i <= m ; i++){
				if(maxx == dp[i]) 
					{res += cnt[i];
if(res >= mod) res -= mod;				
}
			}
			cout << res << endl;
			return 0;
}

背包问题求具体方案

#include <bits/stdc++.h>
using namespace std;

const int maxn = 1010,mod = 1e9 + 7;
int n , m;
int v[maxn],w[maxn];
int dp[maxn][maxn],cnt[maxn];
const int inf = 9999999;


int main(int argc, char const *argv[])
{
	cin >> n >> m;
	for(int  i  = 1; i <= n ; i++) cin >> v[i] >> w[i];

		for(int i = n ; i >= 1; i--) 
			for(int  j = 0; j <= m ; j++){
				dp[i][j] = dp[i+1][j];
				if(j >= v[i]) dp[i][j] = max(dp[i][j] ,dp[i+1][j - v[i]] + w[i]);
			}

	int val = m;
	for(int i  =1; i <= n ;  i++){
		if(dp[i][val] == dp[i+1][val - v[i]] + w[i] && val-v[i]>=0){
			//vol-v[i]>=0
			cout << i << ' ' ;
			val -= v[i];
		}
	}		
	return 0;
}
少侠，慢点走
关注
专栏目录
背包问题（完整版：背包九讲）
Mr_Kingk的博客
02-01 585
1、01背包问题：https://blog.csdn.net/Mr_Kingk/article/details/103964837 2、完全背包问题：https://blog.csdn.net/Mr_Kingk/article/details/104010709 3、多重背包问题（三个版本链接）：https://blog.csdn.net/Mr_Kingk/article/details/10...
背包九讲
热门推荐
pi9nc的专栏
11-03 2万+
【转】背包九讲-dd_engi-第一部分  (2012-03-24 23:26:49) 转载▼ 标签：  背包   动态规划   空间复杂度   物品   杂谈 分类： mass 转载：dd_engi 的背包九讲 目录 第一讲 01背包问题 第二讲 完全背包问题 第三
背包九讲完整版.pdf
10-27
"背包九讲完整版.pdf" 本资源为一份关于动态规划的详细指南，涵盖了背包问题的九个方面，包括基本的背包问题、完全背包问题、多重背包问题、混合三种背包问题、二维费用的背包问题、分组的背包问题、有依赖的背包...
背包问题九讲（转）
weixin_34288121的博客
08-13 86
背包问题 它是在1978年由Merkel和Hellman提出的。它的主要思路是假定某人拥有大量物品，重量各不同。此人通过秘密地选择一部分物品并将它们放 到背包中来加密消息。背包中的物品中重量是公开的，所有可能的物品也是公开的，但背包中的物品是保密的。附加一定的限制条件，给出重量，而要列出可能的物 品，在计算上是不可实现的。背包问题是熟知的不可计算问题，背包体制以其加密，解密速度快而其人注目。但是...
背包问题九讲（非常不错的动态规划讲解，搞ACM必备）
02-10
本篇文章是我(dd_engi)正在进行中的一个雄心勃勃的写作计划的一部分，这个计划的内容是写作一份较为完善的NOIP难度的动态规划总结，名为《解动态规划题的基本思考方式》。现在你看到的是这个写作计划最先发布的一部分。 背包问题是一个经典的动态规划模型。它既简单形象容易理解，又在某种程度上能够揭示动态规划的本质，故不少教材都把它作为动态规划部分的第一道例题，我也将它放在我的写作计划的第一部分。 读本文最重要的是思考。因为我的语言和写作方式向来不以易于理解为长，思路也偶有跳跃的地方，后面更有需要大量思考才能理解的比较抽象的内容。更重要的是：不大量思考，绝对不可能学好动态规划这一信息学奥赛中最精致的部分。 。。。。。。。
经典的背包问题九讲，必看
10-06
背包九讲，经典的背包问题讲解，不用做过多介绍，必看
算法训练 和为T
Go_Accepted的博客
03-19 730
算法训练 和为T   时间限制：1.0s   内存限制：256.0MB      问题描述 　　从一个大小为n的整数集中选取一些元素，使得它们的和等于给定的值T。每个元素限选一次，不能一个都不选。 输入格式 　　第一行一个正整数n，表示整数集内元素的个数。 　　第二行n个整数，用空格隔开。 　　第三行一个整数T，表示要达到的和。 输出格式
背包问题（背包九讲） 学习笔记
Free_FFF的博客
08-22 458
学习了dd大佬的背包九讲之后， 个人的一些学习笔记以及一些看法。 第一讲：01背包问题 /* dp[i][j] 表示前i个物品，容量为j的时候，最大的价值 思路： 将前i件物品放入容量为v的背包中求最大价值这个问题，若只考虑第i件物品的策略（放或不放）， 那么问题就可以转换成涉及前i-1的物品的问题。 此时有两种情况， 1、不放第i件物品，那么问题就转换为前i-1件物品放入容量为j的背包中，...
背包九讲问题记录
AlanfengLiu的博客
05-30 154
背包九讲01背包问题 01背包问题 题目 有N件物品和一个容量为V的背包。第iii件物品的费用是w[i]w[i]w[i]，价值是v[i]，求将哪些物品装入背包可使价值总和最大。 基本思路 这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。 用子问题定义状态：即f[i][j]f[i][j]f[i][j]表示前iii件物品恰放入一个容量为jjj的背包可以获得的最大价值。则其状态转移方程便是： f[i][j]=max(f[i−1][j],f[i−1][j−w[i]]+v[i])f[i][j]=ma
《背包问题九讲》部分注解
文章旨在记录学习过程，希望对你有一点帮助
07-18 1286
dd大牛《背包问题九讲》部分注解（一） 在朋友的推荐下，看过dd_engi写的经典动态规划背包九讲，重新刷新了我对背包问题的认识。同时也感到自己在动态规划方面存在的不足。在认真读完背包九讲后，感觉dd大牛已经道尽了背包问题的精髓。然而动态规划作为信息学奥赛中最为精致的部分，想要学好需要大量的思考，为了让读者更好地理解背包九讲，我决定写这篇《背包问题九讲部分注解》，用更通俗的语言和一些实例帮助大家...
动态规划详解：背包问题九讲
"《背包问题九讲》是一份详尽介绍背包问题的PDF文档，作者致力于创作一套关于动态规划的全面教程，旨在帮助读者理解和掌握动态规划的核心思想。该文档涵盖了01背包、完全背包、多重背包、混合背包、二维费用的背包、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值