01-package 解题报告

最新推荐文章于 2023-01-02 17:17:28 发布

helihui123

最新推荐文章于 2023-01-02 17:17:28 发布

阅读量930

点赞数

分类专栏： judge online 文章标签： list c 测试 struct system input

judge online 专栏收录该内容

48 篇文章 0 订阅

订阅专栏

01-package

时间限制(普通/Java):1000MS/10000MS 运行内存限制:65536KByte
总提交: 32 测试通过: 7

http://acm.tzc.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=2671

描述

给定一个背包的容量k，给定n个物品的体积和价值，物品不可分割，将n个物品中选若干个物品放入背包，求背包内物品的最大价值总和，在价值总和最大的前提下求背包内的最小物品个数c。

输入

第一行是一个整数t，表示测试数据的组数t。
对于每组测试数据，第一行是两个整数n和k,表示物品的个数和背包的容量；
接下来n行，每行两个整数，分别是物品的价值和体积。所有整数都不超过1000。

输出

输出背包内物品的最大价值v，在价值最大的前提下求背包内的最小物品个数c，中间用一个空格隔开。

样例输入

样例输出

10 1


   
   
    
    01背包问题动态规划详解
   
   
   
   
    
    2009-08-11 16:02
   
   
   
   
       
        
         
             
              
               
这是我别人那贴来的 怕自己忘了 记录下来 以后看   呵呵 分类：学习相关 
              
              
               
               动态规划是用空间换时间的一种方法的抽象。其关键是发现子问题和记录其结果。然后利用这些结果减轻运算量。
比如01背包问题。 
                 
               因为背包最大容量M未知。所以，我们的程序要从1到M一个一个的试。比如，开始任选N件物品的一个。看对应M的背包，能不能放进去，如果能放进去，并且还有多的空间，则，多出来的空间里能放N-1物品中的最大价值。怎么能保证总选择是最大价值呢？看下表。
测试数据：
10,3
3,4
4,5
5,6 
                
               c[i][j]数组保存了1,2,3号物品依次选择后的最大价值. 
               这个最大价值是怎么得来的呢?从背包容量为0开始,1号物品先试,0,1,2,的容量都不能放.所以置0,背包容量为3则里面放4.这样,这一排背包容量为4,5,6,....10的时候，最佳方案都是放4.假如1号物品放入背包.则再看2号物品.当背包容量为3的时候，最佳方案还是上一排的最价方案c为4.而背包容量为5的时候，则最佳方案为自己的重量5.背包容量为7的时候，很显然是5加上一个值了。加谁??很显然是7-4=3的时候.上一排c3的最佳方案是4.所以。总的最佳方案是5+4为9.这样.一排一排推下去。最右下放的数据就是最大的价值了。(注意第3排的背包容量为7的时候,最佳方案不是本身的6.而是上一排的9.说明这时候3号物品没有被选.选的是1,2号物品.所以得9.) 
               从以上最大价值的构造过程中可以看出。 
               f(n,m)=max{f(n-1,m), f(n-1,m-w[n])+P(n,m)}这就是书本上写的动态规划方程.这回清楚了吗? 
               下面是实际程序: 
               #include<stdio.h>
int c[10][100];
int knapsack(int m,int n)
{
int i,j,w[10],p[10];
for(i=1;i<n+1;i++)
scanf("/n%d,%d",&w[i],&p[i]);
for(i=0;i<10;i++)
for(j=0;j<100;j++)
c[i][j]=0;
for(i=1;i<n+1;i++)
for(j=1;j<m+1;j++)
{
if(w[i]<=j)
{
if(p[i]+c[i-1][j-w[i]]>c[i-1][j]) 
                 
               
c[i][j]=p[i]+c[i-1][j-w[i]];
else
c[i][j]=c[i-1][j];
}
else c[i][j]=c[i-1][j];
}
return(c[n][m]);

}
int main()
{
int m,n;int i,j;
scanf("%d,%d",&m,&n);
printf("Input each one:/n");
printf("%d",knapsack(m,n));
printf("/n");
for(i=0;i<10;i++)
for(j=0;j<15;j++)
{
printf("%d ",c[i][j]);
if(j==14)printf("/n");
}
system("pause");
}

分析：新想法。
经典的01背包是：list[i][j]=max(list[i-1][j-pack[i].c]+pack[i].v,list[i-1][j]);
现在要统计最大价值下的最小个数  我的想法是每个矩阵的元素都记录当前的物品个数，新加进来的

list[i][j]=max(list[i-1][j-pack[i].c]+pack[i].v,list[i-1][j]);
就这句要换了.... 换成

if(j>=pack[i].c)//表示可以将第i个物品加入           
{
	//如果（要加入的物品价值+（（当前背包容量-要加物品的容量）的背包价值））大于不加该物品的当前价值   
	if((list[i-1][j-pack[i].c]+pack[i].v)>list[i-1][j])  
	{
		list[i][j]=list[i-1][j-pack[i].c]+pack[i].v;    
		num[i][j]=num[i-1][j-pack[i].c]+1;//把该物品加入               
	}
	//如果（要加入的物品价值+（（当前背包容量-要加物品的容量）的背包价值））等于 不加该物品的当前价值       
	else if((list[i-1][j-pack[i].c]+pack[i].v)==list[i-1][j])                
	{
		
		//比较（（当前背包容量-要加物品的容量）的背包物品数量+1 与 当前不加该物品时候的背包里物品数目 取小的一个    
		num[i][j]=min(num[i-1][j],num[i-1][j-pack[i].c]+1);
	}       
}

代码参考：

#include<stdio.h>
#define M 300  //M表示物品数目
#define MAX 399999999
#define min(x,y) x>y?y:x
typedef struct in
{
    int c;
    int v;
    

}node;
node pack[M];

int list[M+1][500],num[M+1][500];

int dp_bb(node pack[],int n,int c)//n表示输入物品个数,c表示背包容量
{


    
    int i,mv,t=0,j;

    
    
    for(i=0;i<=n;i++)//从1开始物品,now 初始化
    {
        list[i][0]=0;
       
    }
    
    for(i=0;i<=c;i++)
    {
        num[0][i]=0;
        list[0][i]=0;
    }//完毕初始化

    //核心代码 
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=c;j++)
        {
            list[i][j]=list[i-1][j];
            num[i][j]=num[i-1][j];
            if(j>=pack[i].c)
            {
                if((list[i-1][j-pack[i].c]+pack[i].v)>list[i-1][j])
                {
                    list[i][j]=list[i-1][j-pack[i].c]+pack[i].v;
                    num[i][j]=num[i-1][j-pack[i].c]+1;
                }
                else if((list[i-1][j-pack[i].c]+pack[i].v)==list[i-1][j])
                {
                    num[i][j]=min(num[i-1][j],num[i-1][j-pack[i].c]+1);

                }
        
            }

        }

    }


    
    mv=list[n][c];



    return mv;
    
}



int main()
{
    int n,c;
    int mv;

    int t,i;
    scanf("%d",&t);
    
    while(t--)
    {
       
    
        scanf("%d%d",&n,&c);
        for(i=1;i<=n;i++)
        {
            scanf("%d%d",&pack[i].v,&pack[i].c);
        }


            mv=dp_bb(pack,n,c);
        

        printf("%d %d/n",mv,num[n][c]);


    }




    return 0;
}

补充：

上面是用二维数组做的0-1背包的，其实一维的就可以完成了的。

从数组最后开始处理，处理起来完全一直。不过要注意下标从1 开始都。

代码：

#include<stdio.h>
#include<string.h>
#define max_size 1005
#define T_size 10005
#define min(x,y) x>y?y:x
typedef struct
{
	int w,v;
}node;

node thing[T_size];
int dlist[max_size],num[max_size];


int main()
{
	int t,i,j,c,n;

	scanf("%d",&n);
	while(n--)
	{
		scanf("%d%d",&t,&c);
		memset(dlist,0,sizeof(dlist[0])*(c+1));
		memset(num,0,sizeof(num[0])*(c+1));

		for(i=1;i<=t;i++)
		{
			scanf("%d%d",&thing[i].v,&thing[i].w);
		
		}
	


		for(i=t;i>=1;i--)
		{
			for(j=c;j>=thing[i].w;j--)
			{
				
				if(dlist[j]<(dlist[j-thing[i].w]+thing[i].v))
				{
					dlist[j]=dlist[j-thing[i].w]+thing[i].v;
					num[j]=num[j-thing[i].w]+1;
				}
				else if(dlist[j]==(dlist[j-thing[i].w]+thing[i].v))
				{
					num[j]=min(num[j-thing[i].w]+1,num[j]);
				}
				
			}
		}
		printf("%d %d/n",dlist[c],num[c]);


		
	}
	return 0;
}