nyoj--289--苹果

苹果

时间限制: 3000 ms  |  内存限制: 65535 KB
难度: 3
描述

ctest有n个苹果,要将它放入容量为v的背包。给出第i个苹果的大小和价钱,求出能放入背包的苹果的总价钱最大值。


输入
有多组测试数据,每组测试数据第一行为2个正整数,分别代表苹果的个数n和背包的容量v,n、v同时为0时结束测试,此时不输出。接下来的n行,每行2个正整数,用空格隔开,分别代表苹果的大小c和价钱w。所有输入数字的范围大于等于0,小于等于1000。
输出
对每组测试数据输出一个整数,代表能放入背包的苹果的总价值。
样例输入
3 3
1 1
2 1
3 1
0 0
样例输出
2


思路:

动态规划题,01背包思想,声明dp[n][v]数组,m[i][j]表示 在进行第i个苹果时,背包容量为j时所能获取的最大值。

下面推状态转移方程

(1)j

(2)j>c[i]时,说明背包可以放下第i个苹果,下面就要考虑,如果装这个苹果能否获取更大的价值,所以:

        dp[i][j]=max(dp[i-1][j],dp[i-1][j-c[i]]+v[i])。dp[i-1][j-c[i]]相当于给这个苹果腾出了c[i]空间

所以状态转移方程为:

 Java Code 
1
2
3
4
5
6
if (j >= c[i])
{
    dp[i][j] = max(dp[i - 
1 ][j], dp[i -  1 ][j - c[i]] + v[i]);
}
else
    dp[i][j] = dp[i - 
1 ][j];

代码:

 Java Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include 
#include 

int  dp[ 1005 ][ 1005 ];

int  max( int  x, int  y)
{
    
if (x>y)
        
return  x;
    
else
        
return  y;
}
int  main()
{
    
int  v1,n;
    
int  c[ 1005 ];
    
int  v[ 1005 ];
    c[
0 ]= 0 ;
    v[
0 ]= 0 ;

    
while (scanf( "%d %d" ,&n,&v1))
    {
        memset(dp,
0 ,sizeof(dp));
        
if (n== 0 &&v1== 0 )
            
break ;

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

        
for ( int  i= 1 ; i<=n; i++)
        {
            
for ( int  j= 1 ; j<=v1; j++)
            {
                
if (j>=c[i])
                {
                    dp[i][j]=max(dp[i-
1 ][j],dp[i- 1 ][j-c[i]]+v[i]);
                }
                
else
                    dp[i][j]=dp[i-
1 ][j];
            }
        }

        printf(
"%d\n" ,dp[n][v1]);

    }
    
return   0 ;
}


空间优化,用一维数组解。

从转移方程:  dp[i][j]=max(dp[i-1][j],dp[i-1][j-c[i]]+v[i]);  看出,每一次要求的dp[i][j]值只与dp[i-1][x] {x:1 2 3 4...j}有关,而dp[i-1][x]是前一次i循环保存下来的,此时考虑是否可以用一维数组d[x]存dp[i-1][x]的值,如果可以那么状态转移方程就变成:

d [ j ] = max( d [ j ] , d [ j - w [ i ] ] + v [ i ] );//此时的d[x]为dp[i-1][x]。

我们知道每一次推出来的dp[i][j]是通过dp[i-1][j-w[i]]推出,而不是dp[i][j-w[i]]。因此j的扫描方式应改为从大到小,这样能保证求出的d [ j - w [ i ] ]是上一次的,即:dp[i-1][j-w[i]]。否则求出的必然是:dp[i][j-w[i]]的值,那就表示  d[i][j] = max(d[i-1][j], d[i][j-w[i]]+v[i]) 这显然是不对的

代码:

 Java Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include 
#include 

int  dd[ 1005 ];
int  max( int  x, int  y)
{
    
if (x>y)
        
return  x;
    
else
        
return  y;
}
int  main()
{
    
int  v1,n;
    
int  c[ 1005 ];
    
int  v[ 1005 ];
    c[
0 ]= 0 ;
    v[
0 ]= 0 ;

    
while (scanf( "%d %d" ,&n,&v1))
    {

        memset(dd,
0 ,sizeof(dd));
        
if (n== 0 &&v1== 0 )
            
break ;
        
for ( int  i= 1 ; i<=n; i++)
            scanf(
"%d %d" ,&c[i],&v[i]);
        
for ( int  i= 1 ; i<=n; i++)
        {
            
for ( int  j=v1; j>=c[i]; j--)
            {
                
if (dd[j]<=v[i]+dd[j-c[i]])
                    dd[j]=v[i]+dd[j-c[i]];
            }
        }
        printf(
"%d\n" ,dd[v1]);
    }
    
return   0 ;
}





你可能感兴趣的:(算法_动态规划)