hdu 3535 AreYouBusy（分组背包的变形---各种分组背包）

最新推荐文章于 2022-05-24 15:05:25 发布
最新推荐文章于 2022-05-24 15:05:25 发布
阅读量861 收藏 1
点赞数
分类专栏： 背包问题 文章标签： system comments class c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wconvey/article/details/7530114
版权

题目分析：0代表每组内的job至少取一件；1代表最多取一件；2代表可以自由取，就相当于对这一组内的job实行01背包......

注意：  1. One job can be done only once.开始没注意到这句话，还以为每组内的每个job可以做多次....囧，，，

             2.这个题花了我一天多的时间，最后看别人的解题报告才过的，，，，

             3.应该先做  hdu  3033的，这个相对于这个简单一些

             4.这个貌似不能压缩空间.....我开始压缩空间做的，一直错，样例都过不了


/*
该题要用分组背包做，这里就是要怎样处理0必须选，1最多选一个，2任意选的问题；
这里我们就开个二维数组；f[i][j]，i表示第组，j表示时间；当该组为0时，我们在
该组的选择可以来自上一组的结果，也可以来自该组的结果；
如果为1那么结果只能依赖上一组的结果，如果依赖本组那么就会造成该组会多选；
为2是那就是一个01背包；
*/
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<memory.h>
using namespace std;
struct node{
    int c,g;
}arr[1000];
int dp[1000][1000];
int main()
{
	int n,t,m,s;
	while(scanf("%d %d",&n,&t)!=EOF)
	{
		memset(dp,-1,sizeof(dp));
		memset(dp[0],0,sizeof(dp[0]));
		for(int x=1;x<=n;x++)
		{
		    scanf("%d %d",&m,&s);
		   // memset(dp,0,sizeof(dp));****不要再犯这样的低级错误
		    for(int i=1;i<=m;i++)
				scanf("%d %d",&arr[i].c,&arr[i].g);
		   
			if(s==0)//每组内.至少取一件,我们在该组的选择可以来自上一组的结果.也可以来自该组的结果；
			{
				 for(int i=1;i<=m;i++)       // for(int i=0;i<=t;i++)
					 for(int k=t;k>=arr[i].c;k--)  // for(int k=1;k<=m;k++)
					 {
						 if(dp[x][k-arr[i].c]!=-1)
							 dp[x][k]=max(dp[x][k],dp[x][k-arr[i].c]+arr[i].g);
//如果dp[i][k-arr[i].c]存在，则表示i组已经取过了，就相当与在去过的基础上再取，即，至少一个
						 if(dp[x-1][k-arr[i].c]!=-1)
						   dp[x][k]=max(dp[x][k],dp[x-1][k-arr[i].c]+arr[i].g);//确保取一个
					 }
			}
			else if(s==1)//每组至多取一件,就是分组背包的原形.
			{//只能依赖上一组的结果，如果依赖本组那么就会造成该组会多选
               for(int k=1;k<=m;k++)//for(int i=t;i>=0;i--)
				   for(int i=t;i>=0;i--)//for(int k=1;k<=m;k++)
				   {
					   dp[x][i]=max(dp[x][i],dp[x-1][i]);
					   if(i>=arr[k].c && dp[x-1][i-arr[k].c]!=-1)
					       dp[x][i]=max(dp[x][i],dp[x-1][i-arr[k].c]+arr[k].g);
				   }
			}
			else//每组内的，可以取任意件，相对于对每一组内的每一件，进行01背包
			{
				for(int k=0;k<=t;k++)
					dp[x][k]=dp[x-1][k];
               for(int k=1;k<=m;k++)
				   for(int i=t;i>=arr[k].c;i--)
					   if(dp[x][i-arr[k].c]!=-1)
					     dp[x][i]=max(dp[x][i],dp[x][i-arr[k].c]+arr[k].g);
			}
	   }
		/*if(dp[n][t]==0)
			printf("-1\n");
		else*/
	     printf("%d\n",dp[n][t]);
	}
	system("pause");
	return 0;
}

/***************************
//有错，压缩空间
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<memory.h>
using namespace std;
struct node{
    int c,g;
}arr[1000];
int dp[1000000];
int main()
{
	int n,t,m,s;
	while(scanf("%d %d",&n,&t)!=EOF)
	{
		memset(dp,0,sizeof(dp));
		for(int x=1;x<=n;x++)
		{
		    scanf("%d %d",&m,&s);
		   // memset(dp,0,sizeof(dp));****不要再犯这样的低级错误
		    for(int i=1;i<=m;i++)
				scanf("%d %d",&arr[i].c,&arr[i].g);
		   
			if(s==0)//每组内.至少取一件,我们在该组的选择可以来自上一组的结果.也可以来自该组的结果；
			{
				   for(int i=1;i<=m;i++)       // for(int i=0;i<=t;i++)
					   for(int k=t;k>=arr[i].c;k--)  // for(int k=1;k<=m;k++)
						   dp[k]=max(dp[k],dp[k-arr[i].c]+arr[i].g);
			}
			else if(s==1)//每组至多去一件,就是分组背包的原形.
			{//只能依赖上一组的结果，如果依赖本组那么就会造成该组会多选
               for(int i=t;i>=0;i--)
				   for(int k=1;k<=m;k++)
					   if(i-arr[k].c>=0)
					       dp[i]=max(dp[i],dp[i-arr[k].c]+arr[k].g);
			}
			else//每组内的，可以取任意件，相对于对每一组内的每一件，进行01背包
			{
               for(int k=1;k<=m;k++)
				   for(int i=t;i>=arr[k].c;i--)
					   dp[i]=max(dp[i],dp[i-arr[k].c]+arr[k].g);
			}
	   }
		if(dp[t]==0)
			printf("-1\n");
		else
	        printf("%d\n",dp[t]);
	}
	system("pause");
	return 0;
}*/


/***************比人的代码

个细节不懂，谁知道的话帮个忙，留个言~
三种背包，每组至少、至多取一个或随意取多少
注释在代码中
?
#include<cstdio>
#include<cstring>
int dp[110][110];
int max(int a,int b)
{
    return a>b?a:b;
}
int main()
{
    int n,T,i,j,k,m,s,w,v;
    while(scanf("%d%d",&n,&T)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        for(i=1;i<=n;i++)
        {
            scanf("%d%d",&m,&s);
            if(s==0)//至少选一个
            {
                for(j=0;j<=T;j++)
                    dp[i][j]=-1;//保证下面会有一个被选中
                for(j=1;j<=m;j++)
                {
                    scanf("%d%d",&w,&v);
                    for(k=T;k>=w;k--)
                    {
                        //下面这两句话为什么一换就错啊，不懂了。。。。
                        if(dp[i][k-w]!=-1)     dp[i][k]=max(dp[i][k],dp[i][k-w]+v);//如果dp[i][k-w]存在，则表示i组已经取过了，就相当与在去过的基础上再取，即，至少一个
                        if(dp[i-1][k-w]!=-1)        dp[i][k]=max(dp[i-1][k-w]+v,dp[i][k]);//保证一定取一个
                    }
                }
            }
            if(s==1)//至多选一个
            {
                for(j=0;j<=T;j++)
                    dp[i][j]=dp[i-1][j];
                for(j=1;j<=m;j++)
                {
                    scanf("%d%d",&w,&v);
                    for(k=T;k>=w;k--)
                    {
                        if(dp[i-1][k-w]!=-1)
                            dp[i][k]=max(dp[i][k],dp[i-1][k-w]+v);
                    }
                }
            }
            if(s==2)//随意选
            {
                for(j=0;j<=T;j++)
                    dp[i][j]=dp[i-1][j];
                for(j=1;j<=m;j++)
                {
                    scanf("%d%d",&w,&v);
                    for(k=T;k>=w;k--)
                    {
                        if(dp[i][k-w]!=-1)
                            dp[i][k]=max(dp[i][k],dp[i][k-w]+v);
                    }
                }
            }
        }
        int ans=-1;
        for(i=0;i<=T;i++)
        {
            if(dp[n][i]>ans)
                ans=dp[n][i];
        }
        printf("%d\n",ans);
    }
    return 0;
}
　　
 
View Code
 
分类: 动态规划
标签: 背包
绿色通道：好文要顶关注我收藏该文与我联系 
Because Of You
关注 - 1
粉丝 - 5
+加关注
0 0
(请您对文章做出评价)
« 博主前一篇：关于分组背包
» 博主后一篇：zstu 1032 拆分物品 再01背包
posted @ 2011-11-19 15:00 Because Of You Views(48) Comments(0) Edit 收藏

*/

/*
该题要用分组背包做，这里就是要怎样处理0必须选，1最多选一个，2任意选的问题；
这里我们就开个二维数组；f[i][j]，i表示第组，j表示时间；
当该组为0时，我们在该组的选择可以来自上一组的结果，也可以来自该组的结果；
如果为1那么结果只能依赖上一组的结果，如果依赖本组那么就会造成该组会多选；
为2是那就是一个01背包；
*/

/*http://www.haogongju.net/art/1343345
#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
class node
{
    public:
    int cost,happy;
};
class Node
{
   public:
   node t[124];
   int type,N; 
};
Node T[124];
int Max( int a, int b )
{
    return a > b ? a : b; 
}
int DP( int n , int time )
{
    int f[124][124]; 
    memset( f , -1 , sizeof( f ) );
    memset( f[0] , 0 ,sizeof(f[0]) );
    for( int i = 1 ; i <= n ; i ++ )
   {
       switch( T[i].type )
       {
          case 0: //至少取一件，即依赖上组，一依赖本组
          for( int j = 0 ; j < T[i].N; j++ )
             for( int k = time ; k >= T[i].t[j].cost ; k-- ) 
            {
                if( f[i][k-T[i].t[j].cost]!=-1 )
                    f[i][k] = Max(f[i][k],f[i][k-T[i].t[j].cost] + T[i].t[j].happy);
                if( f[i-1][k-T[i].t[j].cost]!=-1 )
                    f[i][k] = Max(f[i][k],f[i-1][k-T[i].t[j].cost] + T[i].t[j].happy); 

            } 
            break;
            case 1://至多取一件，只依赖本组
            for( int j = 0 ; j < T[i].N; j++ )
               for( int k = time ; k >= 0 ; k-- )
               {
                   f[i][k] = Max(f[i-1][k],f[i][k]); //????
                   if( k-T[i].t[j].cost>=0&&f[i-1][k-T[i].t[j].cost] != -1 )
                      f[i][k] = Max( f[i][k],f[i-1][k-T[i].t[j].cost] + T[i].t[j].happy );
               }
               break;
           case 2://任意取，01背包
           for( int j = 0 ; j <= time ; j++)
           {
              f[i][j] = f[i-1][j];
           }
           for( int j = 0 ; j < T[i].N; j++ )
			   for( int k = time ; k >0; k-- )
               {
                 if( k-T[i].t[j].cost>=0&&f[i][k-T[i].t[j].cost]!=-1 )
                      f[i][k] = Max(f[i][k], f[i][k-T[i].t[j].cost] + T[i].t[j].happy);
              }
             break;
       } //switch
     }
     return f[n][time];
}
int main( )
{
int n , m , time, type;
while( scanf( "%d%d",&n , &time )==2 )
{
for( int i = 1 ; i <= n ; i++ )
{
scanf( "%d%d",&T[i].N, &T[i].type );
for( int j = 0 ; j < T[i].N ; j++ )
{
scanf( "%d%d",&T[i].t[j].cost , &T[i].t[j].happy );
}

}
printf("%d\n", DP( n , time )); 
}
return 0; 
}
*/

sumi
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hdu3033(分组背包变形)
u013509299的专栏
05-26 506
题意：n个物品，k个组，每个物品只能属于一个组，求至少每个组选一个物品实现的zuida
HDU 3033(I love sneakers!)分组背包变形
小铅笔
08-10 390
看起来很像分组背包，就是每一组的数量至少一，和最多一个又不一样，这里初始化无穷小。这题是看了别人的题解的。 状态转移方程：dp[i][j]表示进行到了第i组容量为j所装载的最大价值。 则dp[i][j]这个状态必须从dp[i-1][j-w[x]]+p[x] （选了第1个第i组的物品），dp[i][j-w[x]]+p[x]（已经选过第i组的物品，这次又选了第i组的物品），dp[i][j]（不选这
【动态规划】分组背包
热门推荐
yu121380的博客
08-03 1万+
问题： 有N件物品，告诉你这N件物品的重量以及价值，将这些物品划分为K组，每组中的物品互相冲突，最多选一件，求解将哪些物品装入背包可使这些物品的费用综合不超过背包的容量，且价值总和最大。   算法： 首先判断一个分组当中的一件物品，同01背包一样，此物品存在两种状态，取与不取，若取此物品，则继续判断下一组的第一件物品，若不取此物品，则继续判断本组下一件物品，若该物品为本组最后一件物品，则判...
洛谷 P3961 [TJOI2013]黄金矿工（分组背包，01背包的变形）
bunny_1024的博客
11-16 309
题目链接： [TJOI2013]黄金矿工 - 洛谷https://www.luogu.com.cn/problem/P3961 思路： 是一个经过变形的01背包题，被挡住的金子不能立刻拿到，（用斜率判断是否在同一直线上，即可知道有没有被挡住），要把其前面的金子拿了才能拿。所以把他们放在一组处理（在代码实现上，需要用二维数组来装物品，一组的放一起）。 代码： #include <bits/stdc++.h> using namespace std; typedef long lo
HDU-2000-2099.rar_hdu
09-19
HDU 里面的2000~2099道题目的源码。谢谢支持
HDU acm-PPT课件
06-07
ACM入门的课件适合于那些想要学习的ACM，提高自己编程能力的。
2-sat---hdu3062
02-11
2-sat---hdu3062,代码详尽，清晰，格式规范，亲测无误。
HDU-EID-V2-核心板1
08-03
可拆卸核心板滤波电容电源指示灯排针复位F103--R10不焊F207--R9不焊第19引脚F103--C4焊0欧姆，C3不焊Tuesday, August 31
HDU-EID-V2-扩展板1
08-04
排母,核心板接口ADC 电位器扩展接口，预留模拟量Tuesday, August 31, 2021Tuesday, August 31, 2021Tuesday
HDU 4341 Gold miner 分组背包变形
九野的博客
10-10 1153
题意： 挖金矿，人在(0,0)点 n个金子 游戏时间为T 下面n行 (x, y) cost val 且若人 和 多块金子共线时，只能先取最近的金子，依次取，就是和游戏一样的。 且所有点只在1 2象限 思路： 我们先把所有共线的点分组 对于每组的物品，我们都可以认为取这个物品的花费就是前面所有物品的花费总和，而价值就是前面所有物品的价值总和。 这样就能消除每组物品的先取后取的影响
HDU_3535_AreYouBusy（多种背包组合）
OTTFF的博客
07-31 751
AreYouBusy Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3887    Accepted Submission(s): 1536 Problem Description Happy New Term! As
HDU 3033——I love sneakers!【分组背包变形】【数据 & 条件的透彻分析】
NIRVANA REBIRTH
10-30 166
题目传送门 分组背包变形，每组都需要选，组内随便选 Problem Description After months of hard working, Iserlohn finally wins awesome amount of scholarship. As a great zealot of sneakers, he decides to spend all his money on th...
【分组背包变形】HDU3033-I love sneakers!
wlxsq的专栏
08-17 405
题目链接：http://acm.split.hdu.edu.cn/showproblem.php?pid=3033 Problem Description After months of hard working, Iserlohn finally wins awesome amount of scholarship. As a great zealot of sneakers,
P5322 [BJOI2019] 排兵布阵[分组背包变形]
meet snow happy
05-24 139
P5322 [BJOI2019] 排兵布阵 题意 [BJOI2019] 排兵布阵 题目描述 小 C 正在玩一款排兵布阵的游戏。在游戏中有 nnn 座城堡，每局对战由两名玩家来争夺这些城堡。每名玩家有 mmm 名士兵，可以向第 iii 座城堡派遣 aia_iai​ 名士兵去争夺这个城堡，使得总士兵数不超过 mmm。 如果一名玩家向第 iii 座城堡派遣的士兵数严格大于对手派遣士兵数的两倍，那么这名玩家就占领了这座城堡，获得 iii 分。 现在小 C 即将和其他 sss 名玩家两两对战，这 sss 场对决的派
O题 分组背包变形
qingyunbiying的专栏
06-01 415
#include #include #include using namespace std; const int maxn=10010; int dp[11][10010]; int belong[10010]; int w[10010],v[10010]; int max(int x,int y) { return x>y?x:y; } int main()
分组背包变形(滚动数组）
bsbxn的博客
02-26 179
Happy New Term! As having become a junior, xiaoA recognizes that there is not much time for her to AC problems, because there are some other things for her to do, which makes her nearly mad. What’s mo...
机器分配（分组背包变形）
Ray.C.L的博客
08-24 230
思路：从题意中我们可以发现，我们可以吧N看为背包组数，M看为背包体积和每组背包的组内个数，矩阵内每个值可以看为i组背包选j个物品的价值，那么这就是个分组背包了，dp[i][j]表示从前i组选出体积小于等于j的最大价值，dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i][k]]+val[i][k])因为这里的v[i][k]是0——m所以直接用k代替。dp[i][j]=max(dp[i-1][j],dp[i-1][j-k]+val[i][k])，然后是求方案，我们枚举可行的方案也就..
51Nod-正整数分组（01背包变形）
信仰.的博客
10-05 474
1007 正整数分组 基准时间限制：1 秒 空间限制：131072 KB 分值: 10 难度：2级算法题  收藏  关注 将一堆正整数分为2组，要求2组的和相差最小。 例如：1 2 3 4 5，将1 2 4分为1组，3 5分为1组，两组和相差1，是所有方案中相差最少的。 Input 第1行：一
A - LOOPS HDU - 3853
最新发布
07-28
回答: 引用\[1\]和引用\[2\]是关于解决HDU - 3853问题的AC代码。这段代码使用了动态规划的思路，通过计算每个点的期望能量来解决问题。其中，f\[i\]\[j\]表示走到(i, j)这个点的期望能量。代码中还有一些特殊情况的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值