背包问题

0-1 背 包：每件物品最多只能用一次
完全背包：每件物品有无限个
多重背包：每件物品的数量有限制
分组背包：有很多组，每组物品中只能选一个

0-1背包问题

#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int w[N], v[N];
int f[N][N]; //f(n,v)表示从前n个物品中选择，体积不超过v总价值的最大值
//对于每一个f(i,j)都可以分为两个集合，含有i，和不含有i，即从1~i中选择或者1~i-1中选择
//当不含有i，最大值是f(i-1,j)
//当含有i，最大值是从1~i-1中选择权值不超过j-vi的点，即f(i-1,j-vi) + wi
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++) //考虑i件物品
    {
        for (int j = 0; j <= m; j++) //考虑总体积不超过j
        {
            f[i][j] = f[i - 1][j]; //不装这个物品的情况一定存在
            if (j >= v[i]) //如果体积小于vi则说明装不下这个物品，说明这种情况不存在
                f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
        }
    }
    cout<<f[n][m]<<endl;
    return 0;
}

对于动态规划问题的优化就是对状态转移方程进行等价变形
对于这道题来讲，直接删掉一维数组之后，用滚动数组，对于第二重循环来说，j 从0~v[i-1] 这些是没有意义的，所以这一部分循环可以直接跳过，题中的第二重循环从大到小进行枚举是因为后面的循环是没有没更新过的，还是算的 i-1 层，这样与之前的变形才是等价的

#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N];
int f[N];
int main()
{
    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--)
            f[j] = max(f[j], f[j - v[i]] + w[i]);
    cout << f[m] << endl;
    return 0;
}

完全背包问题

朴素做法，与上面的0-1背包问题比较类似，但是时间复杂度很高，这里会TLE

#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int v[N], w[N];
int f[N][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++)                //枚举前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 - v[i] * k] + w[i] * k);
    cout<<f[n][m]<<endl;
    return 0;
}

接下来是对这个代码的优化

#include <bits/stdc++.h>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N][N];
int main()
{
    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++)
        {
            f[i][j]=f[i-1][j];
            if(j>=v[i]) f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);
        }
    cout<<f[n][m]<<endl;
    return 0;
}

由状态转移方程，可知第i层只需要用到第i-1层
因此可以优化成一维的，类似于0-1背包中的优化

#include <bits/stdc++.h>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N];
int main()
{
    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;
    return 0;
}

多重背包问题

多重背包问题 I

这里状态转移方程和完全背包问题相同，只不过k给定了一个范围
这道题可以直接用暴力做法

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m;
int v[N], w[N], s[N];
int f[N][N];
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> v[i] >> w[i] >> s[i];
    for (int i = 1; i <= n; i++)
        for (int j = 0; j <= m; j++)
            for (int k = 0; k <= s[i] && k * v[i] <= j; k++)
                f[i][j] = max(f[i][j], f[i - 1][j - v[i] * k] + w[i] * k);
    cout << f[n][m] << endl;
    return 0;
}

在这里可以利用二进制的思想对这题进行优化
将每一组的前几个物品进行打包，这样即可表示为每个打包之后的物品只能取一次
这样就将问题转化为了0-1背包问题

#include <bits/stdc++.h>
using namespace std;
const int N=25000,M=2010;
int n,m;
int v[N],w[N];
int f[N];
int main()
{
    cin>>n>>m;
    int cnt=0;
    for(int i=0;i<n;i++)
    {
        int a,b,s;
        cin>>a>>b>>s;
        int k=1;
        while(k<=s)
        {
            cnt++;
            v[cnt]=a*k;
            w[cnt]=b*k;
            s-=k;
            k*=2;
        }
        if(s>0)
        {
            cnt++;
            v[cnt]=a*s;
            w[cnt]=b*s;            
        }
    }
    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;
    return 0;
}

分组背包问题

这个相比于前面的来讲就比较暴力了，没有什么优化
直接枚举所有的组，所有的体积，所有的选择即可

#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m;
int v[N][N], w[N][N], s[N];
int f[N];
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        cin >> s[i];
        for (int j = 0; j < s[i]; j++)
            cin >> v[i][j] >> w[i][j];
    }
    for (int i = 1; i <= n; i++)           //枚举每一组
        for (int j = m; j >= 0; j--)       //枚举所有体积
            for (int k = 0; k < s[i]; k++) //枚举所有选择
                if (v[i][k] <= j)
                    f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
    cout << f[m] << endl;
    return 0;
}