01背包问题----（动态规划算法）

最新推荐文章于 2024-08-12 23:43:34 发布

千寻～

最新推荐文章于 2024-08-12 23:43:34 发布

阅读量1.1k

点赞数

分类专栏： ACM算法文章标签： 01背包动态规划

ACM算法专栏收录该内容

40 篇文章 0 订阅

订阅专栏

0-1 背包问题：给定 n 种物品和一个容量为 C 的背包，物品 i 的重量是 wi，其价值为 vi 。

问：应该如何选择装入背包的物品，使得装入背包中的物品的总价值最大？

分析一波：面对每个物品，我们只有选择拿取或者不拿两种选择，不能选择装入某物品的一部分，也不能装入同一物品多次。

解决办法：声明一个大小为 m[n][c]（表示当前总价值） 的二维数组，m[ i ][ j ] 表示在面对第 i 件物品，且背包容量为 j（没装任何物品时的容量，假设背包就那么大，只有容量 j ）时所能获得的最大价值，那么我们可以很容易分析得出 m[i][j] 的计算方法，

（1）j < w[i] 的情况，这时候背包容量不足以放下第 i 件物品，只能选择不拿

m[ i ][ j ] = m[ i-1 ][ j ] （不拿物品时，价值等于考虑第 i-1 件时的价格）

（2）j>=w[i] 的情况，这时背包容量可以放下第 i 件物品，我们就要考虑拿这件物品是否能获取更大的价值。

如果拿取，m[ i ][ j ]=m[ i-1 ][ j-w[ i ] ] + v[ i ]。这里的m[ i-1 ][ j-w[ i ] ]指的就是考虑了i-1件物品，背包容量为j-w[i]时的最大价值，也是相当于为第i件物品腾出了w[i]的空间。

如果不拿，m[ i ][ j ] = m[ i-1 ][ j ] , 同（1）

究竟是拿还是不拿，自然是比较这两种情况那种价值最大。

由此可以得到状态转移方程：

if(j>=w[i])
    m[i][j]=max( m[i-1][j], m[i-1][j-w[i]]+v[i]  );
else
    m[i][j]=m[i-1][j];

例：0-1背包问题。在使用动态规划算法求解0-1背包问题时，使用二维数组m[i][j]存储，m[i][j]数组值表示价值，背包容量为j，可选物品为i、i+1、……、n时0-1背包问题的最优值。绘制

价值数组v = {8, 10, 6, 3, 7, 2}，

重量数组w = {4, 6, 2, 2, 5, 1}，

背包容量C = 12时对应的m[i][j]数组。

0	1	2	3	4	5	6	7	8	9	10	11	12
1	0	0	0	8	8	8	8	8	8	8	8	8
2	0	0	0	8	8	10	10	10	10	18	18	18
3	0	6	6	8	8	14	14	16	16	18	18	24
4	0	6	6	9	9	14	14	17	17	19	19	24
5	0	6	6	9	9	14	14	17	17	19	21	24
6	2	6	8	9	11	14	16	17	19	19	21	24

(第一行和第一列为序号，其数值为0)

如m[2][6],在面对第2件物品，背包容量为6时，

我们可以选择不拿，那么获得价值仅为第一件物品的价值8。

即：m[ 2 ][ 6 ] = m[1 ][ 6 ] （m[ i ][ j ] = m[ i-1 ][ j ]）

如果拿，就要把第一件物品拿出来，放第二件物品，价值10，那我们当然是选择拿。

即：m[2][6] = m[2-1][6-6]+10 =0+10 = 10（m[ i ][ j ]=m[ i-1 ][ j-w[ i ] ] + v[ i ]）

依次类推，得到m[6][12]就是考虑所有物品，背包容量为C时的最大价值。

#include <iostream>
using namespace std;

const int N=15;

int main() {
    int v[N]={0,8,10,6,3,7,2};//注意这里多了一个前导0
    int w[N]={0,4,6,2,2,5,1};

    int m[N][N];
    int n=6,c=12;
    memset(m,0,sizeof(m));
    for(int i=1;i<=n;i++) { //注意前导第0列元素为0
        for(int j=1;j<=c;j++) {
            if(j>=w[i])
                m[i][j]=max(m[i-1][j],m[i-1][j-w[i]]+v[i]); //最优子结构
            else
                m[i][j]=m[i-1][j];
        }
    }

    for(int i=1;i<=n;i++) {    //输出序列
        for(int j=1;j<=c;j++) {
            cout<<m[i][j]<<' ';
        }
        cout<<endl;
    }

    return 0;
}

0 0 0 8 8 8 8 8 8 8 8 8
0 0 0 8 8 10 10 10 10 18 18 18
0 6 6 8 8 14 14 16 16 18 18 24
0 6 6 9 9 14 14 17 17 19 19 24
0 6 6 9 9 14 14 17 17 19 21 24
2 6 8 9 11 14 16 17 19 19 21 24

到这一步，可以确定的是可能获得的最大价值，但是我们并不清楚具体选择哪几样物品能获得最大价值。

另起一个 x[ ] 数组，x[i]=0表示不拿，x[i]=1表示拿。

m[n][c]为最优值，如果m[n][c]=m[n-1][c] ,说明有没有第n件物品都一样，则x[n]=0 ; 否则 x[n]=1。当x[n]=0时，由x[n-1][c]继续构造最优解；当x[n]=1时，则由x[n-1][c-w[i]]继续构造最优解。以此类推，可构造出所有的最优解。

[cpp]view plain copy
void traceback()  
{  
    for(int i=n;i>1;i--)   //注意这里是2-n，没有处理i=1
    {  
        if(m[i][c]==m[i-1][c])  
            x[i]=0;  //没拿
        else  
        {  
            x[i]=1;  //拿了
            c-=w[i];  
        }  
    }  
    x[1]=(m[1][c]>0)?1:0;  //这里处理i=1
}  

例：

某工厂预计明年有A、B、C、D四个新建项目，每个项目的投资额W_k及其 投资后的收益V_k如下表所示，投资总额为30万元，如何选择项目才能使总收益最大？

Project项目	W_k投资额	V_k收益
A	15	12
B	10	8
C	12	9
D	8	5

结合前面两段代码

 
    
  
#include <iostream>  
#include <cstring>  
using namespace std;  
  
const int N=150;  
  
int v[N]={0,12,8,9,5};  
int w[N]={0,15,10,12,8};  
int x[N];  
int m[N][N];  
int c=30;  
int n=4;  
void traceback()  
{  
    for(int i=n;i>1;i--)  
    {  
        if(m[i][c]==m[i-1][c])  
            x[i]=0;  
        else  
        {  
            x[i]=1;  
            c-=w[i];  
        }  
    }  
    x[1]=(m[1][c]>0)?1:0;  
}  
  
int main()  
{    
    memset(m,0,sizeof(m));  
    for(int i=1;i<=n;i++)  
    {  
        for(int j=1;j<=c;j++)  
        {  
            if(j>=w[i])  
                m[i][j]=max(m[i-1][j],m[i-1][j-w[i]]+v[i]);  
            else  
                m[i][j]=m[i-1][j];  
        }  
    }
/* 
    for(int i=1;i<=6;i++) 
    { 
        for(int j=1;j<=c;j++) 
        { 
            cout<<m[i][j]<<' '; 
        } 
        cout<<endl; 
    } 
*/  
    traceback();  
    for(int i=1;i<=n;i++)  
        cout<<x[i];  
    return 0;  
}  

输出x[i]数组：0111，输出m[4][30]：22。

得出结论：选择BCD三个项目总收益最大，为22万元。

不过这种算法只能得到一种最优解，并不能得出所有的最优解。

其他人解法：空间优化

#include<bits/stdc++.h>  
using namespace std;  
int dp[1005][1005];  
int weight[1005];  
int value[1005];  
int main()  
{  
    int n,m;  
    cin>>m>>n;  
    memset(dp,0,sizeof(dp));//数组清空,其实同时就把边界给做了清理  
    for(int i=1; i<=n; i++)  
        cin>>weight[i]>>value[i];  
    //从1开始有讲究的因为涉及到dp[i-1][j],从0开始会越界  
    for(int i=1; i<=n; i++)//判断每个物品能否放进  
    {  
        for(int j=0; j<=m; j++)//对每个状态进行判断  
        //这边两重for都可以倒着写，只是需要处理最边界的情况，滚动数组不一样  
        {  
            if(j>=weight[i])//能放进  
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);  
  
            else dp[i][j]=dp[i-1][j];//不能放进  
        }  
    }  
    cout<<dp[n][m]<<endl;  
    return 0;  
}  

然后啊，我们来仔细分析分析就会发现，这个数组开销还是很大的，因为是二维的，万一哪个数据一大，分分钟内存超限，因此有了下边的解法

传说中的---------------滚动数组！！！

啊？什么是滚动数组。

说白了二维数组只是把每个物品都跑一遍，然后到最后一个物品的时候输出答案，那么过程值只是计算的时候用一次，我没必要存下来。所以用一个数组去滚动存储，然后用后一个状态的值去覆盖前面一个状态。然后形象的叫它：滚动数组（ma！dan！一点都不形象，我理解了好久）

好吧，假装很形象。

那么问题来了，怎么样用一维的去代替二维的工作，或者说怎么去思考。这是一个难点。

那么我们想，遍历物品的那个for肯定不能省去，然后里边的for也不能省。。。。那么。就把那个i给他删了吧，好像确实没啥用哦。

然后就出现了这样的代码

[cpp]view plain copy
for(int i=1; i<=n; i++)  
   {  
       for(int j=weight[i]; j<=m; j++)  
       {  
           dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);  
       }  
   }  

看上去好像很厉害的样子,但是这个绝对是错的，因为第二个for里存在某个dp[j]被改动过，然后再次影响到更大的j。就像我们再对一个数组进行移位操作，一不小心就全部成了一样的数。（别笑，你们以前肯定碰到过|||- -）

额。。回到正题，上边的代码会有重复影响，确实歪打正着的碰上了另一个背包。这个另说，现在附上正确的思路。

[cpp]view plain copy
#include<bits/stdc++.h>  
using namespace std;  
int dp[1005];//滚动数组的写法，省下空间省不去时间  
int weight[1005];  
int value[1005];  
int main()  
{  
    int n,m;  
    cin>>m>>n;  
    memset(dp,0,sizeof(dp));  
    for(int i=1; i<=n; i++)  
        cin>>weight[i]>>value[i];  
    for(int i=1; i<=n; i++)//对每个数判断，可反  
    {  
        for(int j=m; j>=weight[i]; j--)//这里这个循环定死，不能反,反了就是完全背包  
        {  
            dp[j]=max(dp[j],dp[j-weight[i]]+value[i]);//其实不断在判断最优解，一层一层的  
        }  
    }  
    cout<<dp[m]<<endl;  
    return 0;  
}  