背包问题

一：0 1背包（每个物品选一次）

有

第

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式

第一行两个整数，

接下来有

输出格式

输出一个整数，表示最大价值。

数据范围

输入样例

输出样例：

`8`

朴素做法：

思路：dp[i][j]表示前i个物品，体积为j的最优解。

对于第i个物品可选可不选。不选的dp[i][j]=dp[i-1][j];

选的话就是dp[i][j]=dp[i-1][j-v[i]]+w[i];为什么呢，因为体积最大就只能是刚好，那么前i-1个物品就要腾出空间给第i个物品，那前i个物品腾出的空间就是j-v[i];前提是j>=v[i],不然腾不出空间。

#include<bits/stdc++.h>

using namespace std;

const int MAXN = 1005;
int v[MAXN]; // 重量 
int w[MAXN]; // 价值 
int f[MAXN][MAXN]; // f[i][j], j重量下前i个物品的最大价值

int main() 
{
int n, m; 
cin >> n >> m;
for(int i = 1; i <= n; ++i) 
cin >> v[i] >> w[i];

for(int i = 1; i <= n; ++i) 
for(int j = 1; j <= m; ++j)
{

if(j <v[i]) 
f[i][j] = f[i-1][j];//太小了只能不选，

else //选的话，在选和不选中取max
f[i][j] = max(f[i-1][j], f[i-1][j-v[i]] + w[i]);
}

cout << f[n][m];
return 0;
}

优化版：

思路：上面的代码中我们可以发现，f[i][j]的时候我们只用到了前面，我们只用到了f[i-1][j]或者f[i-1][j-v[i]，所以我们可以按顺序枚举i，即for(int i = 1; i <= n; i++),就可以保证我们每次都是用前面一层，所以可以将二维数组浓缩成一维数组;

在发现如果只剩下一维数组了，当我们不选的时候，f[i][j] = f[i-1][j]就变成了f[j]=f[j]，默认成立，这句就可以去掉了，所以我们可以直接从j>=w[i]枚举到m，但是我们发现f[j] = max(f[j], f[j-v[i]] + w[i])这句话是第i层更新的，为什么呢，因为j从v[i]开始枚举，j-v[i]就<j,就会将f[j]从小到大在第i层更新了一遍，就将前面第i-1层的结果给覆盖掉了，所以我们选择逆序，从m开始枚举到v[i]；即for(int j = m; j >= v[i]; j--)

#include<bits/stdc++.h>

using namespace std;

const int MAXN = 1005;
int v[MAXN]; // 重量
int w[MAXN]; // 价值
int f[MAXN];                                            //int f[MAXN][MAXN]; // f[i][j], j重量下前i个物品的最大价值

int main()
{
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; i++)
        cin >> v[i] >> w[i];

    for(int i = 1; i <= n; i++)
        for(int j = m; j >= v[i]; j--)                        // for(int j = 1; j <= m; ++j)
        {

                                                             //            if(j < w[i])
            //f[j]=f[j];                                    //                f[i][j] = f[i-1][j];//太小了只能不选，

            // else //选的话，在选和不选中取max
            f[j] = max(f[j], f[j-v[i]]+w[i]);               //  f[i][j] = max(f[i-1][j], f[i-1][j-w[i]] + v[i]);
        }

    cout<<f[m]<<endl;                                        //cout << f[n][m];
    return 0;
}

二：完全背包（每个物品有无限个）

与01背包区别就是每个物品有无限个，要求一样，求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

思路：f[i][j]表示前i个体积不超过j的最优解。

f[i][j]=max{f[i-1][j-k*v[i]]+k*w[i]|0<=k*v[i]<=m}//k 表示物品取的个数,v[i]表示第i种物品的体积,w[i]表示第i种物品的价值

#include<iostream>
using namespace std;
const int N = 1010;
int f[N][N];
int v[N],w[N];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i = 1 ; i <= n ;i ++)
    {
        cin>>v[i]>>w[i];
    }

    for(int i = 1 ; i<=n ;i++)
    for(int j = 0 ; j<=m ;j++)
    {
        for(int k = 0 ; k*v[i]<=j ; k++)
            f[i][j] = max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
    }

    cout<<f[n][m]<<endl;
}

优化：

f[i , j ] = max( f[i-1,j] , f[i-1,j-v]+w , f[i-1,j-2*v]+2*w , f[i-1,j-3*v]+3*w , .....)
f[i , j-v]= max( f[i-1,j-v] , f[i-1,j-2*v] + w , f[i-1,j-2*v]+2*w , .....)
由上两式，f[i][j]=max(f[i,j-v]+w , f[i-1][j])

所以循环可以变成下面这样

for(int i = 1 ; i <=n ;i++)
for(int j = 0 ; j <=m ;j++)
{
    f[i][j] = f[i-1][j];
    if((j-v[i]>=0)
        f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);
}

最后发现每一层状态只和当前这一层有关系，所以可以把数组改为一维的。和01背包类似

#include<iostream>
using namespace std;
const int N = 1010;
int f[N];
int v[N],w[N];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i = 1 ; i <= n ;i ++)
    {
        cin>>v[i]>>w[i];
    }

    for(int i = 1 ; i<=n ;i++)
    for(int j = v[i] ; j<=m ;j++)
    {
            f[j] = max(f[j],f[j-v[i]]+w[i]);
    }
    cout<<f[m]<<endl;
}

三：多重背包（每个物品有限个）

1.有

第

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。

输入：第
思路：f[i][j]表示前i个物品，体积不超过j的最优解

f[i][j]=max(f[i-1][j],f[i-1][j-v[i]*k]+w[i]*k]);(k=0,1,2,....si)

优化后变成：f[j]=max(f[j],f[j-v[i]*k]+w[i]*k);(k=0,1,2,....si)//与01背包类似

#include<iostream>
#include<algorithm>
using namespace std;
int n,m;
int f[105];
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int v,w,s;
        cin>>v>>w>>s;
        for(int j=m;j>=0;j--)
        {
            for(int k=1;k<=s&&k*v<=j;k++)
            {
                f[j]=max(f[j],f[j-k*v]+k*w);
            }
        }
    }
    cout<<f[m]<<endl;







    return 0;
}

View Code

2.二进制优化：

把s拆成 1,2,4,...2^k,c//其中c=s-2^k+1-1;（由二进制原理得）这样就可以将s拆成logs+1个，转化成01背包

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 25000;
int f[N];
int v[N], w[N];
int n, m;
int main()
{
    cin >> n >> m;
    int cnt = 0;
    for (int i = 1; i <= n; i++)
    {
        int k = 1;
        int a, b, c;
        cin >> a >> b >> c;
        while (k <= c)
        {
            cnt++;
            v[cnt] = k * a;
            w[cnt] = k * b;
            c -= k;
            k *= 2;
        }
        if (c > 0)
        {
            cnt++;
            w[cnt] = b * c;
            v[cnt] = a * c;
        }
    }
    n = cnt;
    for (int i = 1; i <= n; i++)
    {
        for (int j = m; j >= v[i]; j--)
        {
            f[j] = max(f[j], f[j - v[i]] + w[i]);
        }
    }
    cout << f[m] << endl;
}