动态规划——背包问题

01背包问题

• 问题描述

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

• 分析
  
  关键是用前边的状态来更新当前状态，就是将一个问题分解为子问题，由子问题的最优解来得出当前问题的最优解。
  同时还有根据实际意义确定边界值

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int dp[N][N];
int v[N],w[N];
int n,m;

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d%d",&v[i],&w[i]);
    //这里边界就是选择0个时所有价值都是0，同时体积为零时也是0，在dp中更新。
    for(int i=1;i<=n;i++)
        for(int j=0;j<=m;j++){
            dp[i][j] = dp[i-1][j];
            if(j>=v[i])dp[i][j] = max(dp[i][j],dp[i-1][j-v[i]]+w[i]);
        }
        printf("%d",dp[n][m]);
    return 0;
}

• 空间优化为一维
  我么可以发现，每一层的更新都由上一层更新而来，且只有当j大于等于v[i]时才进行更新，所以二维数组中存储了很多无用的元素，造成空间的浪费。因此考虑优化为一维数组存储。dp[j]表示当前到低i层时体积为j时的解。
  但是，由于dp[i][j] = max(dp[i][j],dp[i-1][j-vi]+w[i])
  如果换成一维后还从前到后进行内层循环，由于j-vi一定小于j，也就是用前边的值更新后边的值，在前边的操作时可能更新了dp[j-vi],而不是第i-1层时的数据，但是如果倒着更新，即j从m开始减到vi，在进行内存循环先更新了后边的值，则前边的值一定是上层更新时保留的值，而更新前边的值时，不会用到后边已经更新的值，所有倒着更新可以得到正确答案。

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int dp[N];
int v[N],w[N];
int n,m;

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d%d",&v[i],&w[i]);
    for(int i=1;i<=n;i++)
        for(int j=m;j>=v[i];j--){
            dp[j] = max(dp[j],dp[j-v[i]]+w[i]);
        }
        printf("%d",dp[m]);
    return 0;
}

完全背包问题

• 问题描述

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。
第 i 种物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

• 分析
  
• 朴素解法

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int dp[N][N],v[N],w[N];
int n,m;


int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d%d",&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++)//枚举可能的取得个数。
                dp[i][j] = max(dp[i][j],dp[i-1][j-k*v[i]]+k*w[i]);
    }
    printf("%d",dp[n][m]);
    return 0;
}

上边解法时间复杂度近似O(n³)，最后就被卡了一个数据，进行优化。

• 优化
  

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int dp[N][N],v[N],w[N];
int n,m;


int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d%d",&v[i],&w[i]);
    for(int i=1;i<=n;i++){
        for(int j=0;j<=m;j++){
            dp[i][j] = dp[i-1][j];
            if(j>=v[i])dp[i][j] = max(dp[i][j],dp[i][j-v[i]]+w[i]);
        }
    }
    printf("%d",dp[n][m]);
    return 0;
}

• 空间继续优化
  与01背包问题一样，可以优化为一维，由于每次dp的更新是从当前层更新的，所以，不用倒着进行内层循环了，直接正着进行内层循环就行了。

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int dp[N],v[N],w[N];
int n,m;


int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d%d",&v[i],&w[i]);
    for(int i=1;i<=n;i++){
        for(int j=v[i];j<=m;j++){
            dp[j] = max(dp[j],dp[j-v[i]]+w[i]);
        }
    }
    printf("%d",dp[m]);
    return 0;
}

多重背包问题

• 描述

有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

• 分析
  
• 朴素版本
  当数量较少时，直接按照转移方程三重循环即可解决。
  代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N = 110;
int f[N][N],v[N],w[N],s[N];
int n,m;

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%d%d%d",&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*v[i]<=j&&k<=s[i];k++){
                f[i][j] = max(f[i][j],f[i-1][j-k*v[i]]+w[i]*k);
            }
        }
    }
    printf("%d",f[n][m]);
    return 0;
}

• 二进制优化版本
  当数量很多时，朴素版本时间复杂度很大，就过不去了，然后就得优化。
  首先考虑利用完全背包的推导进行优化，但是发现并没有类似的规律，所以得另辟蹊径。用二进制进行优化。

首先，1,2,4,8,16,32…根据前几个数可以表示出0到相关的数，例如1,2可以表示0-3的所有数，以此类推，可以发现，1-2^k可以表示0-2^k-1的所有数，所以可以将每种物品的si进行二进制划分，找到不大于si的所有二进制数的和，然后再补充一个相应的数，就可以表示si，也就是可以在第i种中取所有划分的情况，且必须取完，这就变成了01背包问题，最终优化成了O(nlogkm)的时间复杂度。

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N = 2e4+50;
int f[N],v[N],w[N];
int n,m;


int main()
{
    scanf("%d%d",&n,&m);
    int cnt = 0;
    while(n--){
        int a,b,s;
        scanf("%d%d%d",&a,&b,&s);
        int k = 1;
        while(k<=s){//这里划分就很妙
            cnt++;
            v[cnt] = a*k;
            w[cnt] = b*k;
            s -= k;
            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]);
    
    printf("%d\n",f[m]);
    return 0;
}

分组背包问题

• 描述

有 N 组物品和一个容量是 V 的背包。
每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。
输出最大价值。

• 分析
  
  由于是从第i-1的状态转移而来，可以优化为一维的。
  代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N = 110;
int f[N],s[N],v[N][N],w[N][N];
int n,m;


int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&s[i]);
        for(int j=1;j<=s[i];j++)
            scanf("%d%d",&v[i][j],&w[i][j]);
    }
    for(int i=1;i<=n;i++)
        for(int j=m;j>=0;j--)
            for(int k=1;k<=s[i];k++)
                if(v[i][k]<=j)f[j] = max(f[j],f[j-v[i][k]]+w[i][k]);
    printf("%d",f[m]);
    return 0;
}