nyoj--289--苹果

最新推荐文章于 2018-08-25 10:35:55 发布

职业炮灰

最新推荐文章于 2018-08-25 10:35:55 发布

阅读量200

点赞数

CC 4.0 BY-SA版权

分类专栏：算法_动态规划文章标签： 01背包问题 nyoj

本文链接：https://blog.youkuaiyun.com/king_cannon_fodder/article/details/80083389

算法_动态规划专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一种使用动态规划解决苹果背包问题的方法，包括01背包思想的应用及状态转移方程的推导，并提供了两种实现代码，一种使用二维数组，另一种通过空间优化采用一维数组。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

苹果

时间限制：3000 ms | 内存限制：65535 KB

难度：3

描述

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

输入

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

输出

对每组测试数据输出一个整数，代表能放入背包的苹果的总价值。

样例输入

样例输出

思路：

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

下面推状态转移方程

（1）j<c[i]时，这时背包容量不够装第i个苹果，只能选择不拿所以：dp[i][j]=dp[i-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 <math.h>
#include <bits/stdc++.h>

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 <math.h>
#include <bits/stdc++.h>

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;
}