C++知识点总结(59)：背包型动态规划

一、背包 dp

1. 01 背包（限量）

假如有这几个物品（前面的数是价值，后面的数是体积）：（5，2）（18，7）（14，6）

则推导的 dp[][] 表格应该如下（行表示宝石个数，列表示背包容量变化）：

	0	1	2	3	4	5	6	7	8
0	0	0	0	0	0	0	0	0	0
1	0	0	5	5	5	5	5	5	5
2	0	0	5	5	5	5	5	18	5
3	0	0	5	5	5	5	14	18	19

总的来说，可以用下面流程图简单概括：

容量<宝石体积（装不进）：
    dp[i][j]=dp[i-1][j]
容量>=宝石体积（装或不装）：
    dp[i][j]=max{dp[i-1][j],dp[i-1][j-w[i]]+v[i]}

模板：

#include<bits/stdc++.h>
using namespace std;
int n,m,w[10005],v[10005],dp[10005];
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        cin>>w[i]>>v[i];
    for(int i=1;i<=n;i++)
        for(int j=m;j>=w[i];j--)
            dp[j]=max(dp[j],v[i]+dp[j-w[i]]);
    cout<<dp[m];
    return 0;
}

2. 完全背包（不限量）

假如有这几个物品（前面的数是价值，后面的数是体积）：（2，3）（3，4）（4，5）

则推导的 dp[][] 表格应该如下（行表示宝石个数，列表示背包容量变化）：

	0	1	2	3	4	5	6	7	8
0	0	0	0	0	0	0	0	0	0
1	0	0	0	3	3	3	6	6	6
…

模板：

#include<bits/stdc++.h>
using namespace std;
int n,m,v[10005],e[10005],dp[10005];
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        cin>>v[i]>>e[i];
    for(int i=1;i<=n;i++)
        for(int j=v[i];j<=m;j++)
            dp[j]=max(dp[j],e[i]+dp[j-v[i]]);
    cout<<dp[m];
    return 0;
}

3. 口诀

遇到 dp 怎么办？凉拌炒鸡蛋，洛谷上面加颗蛋。翻个面，金灿灿，01 完全背模板。

二、例题

1. 和是质数的子集数

给出 $n$ 个正整数，问存在多少个子集，使得子集中所有数的和是质数。

#include<bits/stdc++.h>
using namespace std;
const int MAXN=5e2+8;
const int MAXS=1e5+8;
const int MOD=1e9+7;
int n,s,a[MAXN],dp[MAXS];
bool isPrime(int n){
    if(n<2)return 0;
    for(int i=2;i*i<=n;i++)
        if(n%i==0)
            return 0;
    return 1;
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i],s+=a[i];
    dp[0]=1;
    for(int i=1;i<=n;i++)
        for(int j=s;j>=a[i];j--)
            dp[j]=(dp[j]+dp[j-a[i]])%MOD;
    int ans=0;
    for(int i=2;i<=s;i++)
        if(isPrime(i))
            ans=(ans+dp[i])%MOD;
    cout<<ans;
    return 0;
}

2. 黄金的太阳

黄金的太阳独创了一种精灵召唤技能。玩家在冒险中收集精灵，然后就可以在战斗中利用精灵的能量，使用各种召唤技能。
每种召唤技能需要消耗精灵的能量，玩家的精灵能提供的总能量等于 $m$ 点。当释放召唤技能时，根据技能的消耗，需要同等数量的能量，消耗掉的能量不会再恢复。只要有足够的能量，每种技能都可以无限次使用。
玩家目前收集的精灵能够提供的能量等于 $m$ 点。有 $n$ 种不同的召唤技能可以使用，第 $i$ 种技能的消耗为 $c_i$ 点能量，伤害为 $d_i$。
敌人的体力为 $H$，当总伤害大于等于 $H$ 时，敌人就被击败了。问击败敌人时，还剩下的（可以提供能量的）精灵的最多数量。如果无法击败敌人，输出 −1。

#include<bits/stdc++.h>
using namespace std;
const int MAXN=1e2+8;
const int MAXH=1e5+8;
const int INF=0x3f3f3f3f;
int n,m,h,c[MAXN],d[MAXN],dp[MAXH];
int main(){
    cin>>n>>m>>h;
    for(int i=1;i<=n;i++)
        cin>>c[i]>>d[i];
    memset(dp,INF,sizeof(dp));
    dp[0]=0;
    for(int i=1;i<=n;i++)
        for(int j=0;j<=h;j++)
            dp[j]=min(dp[j],dp[max(0,j-d[i])]+c[i]);
    cout<<max(-1,m-dp[h]);
    return 0;
}

3. 负数子集和

#include<bits/stdc++.h>
using namespace std;
const int MAXN=5e1+8;
const int MAXS=1e4+8;
const int MOD=998244353;
int n,s;
map<int,int>dp;//和为j的子集总数
int main(){
    cin>>n>>s;
    dp[0]=1;
    for(int i=1,a;i<=n;i++){
        cin>>a;
        if(a>=0)
            for(int j=MAXS;j>=-MAXS;j--)
                dp[j]=(dp[j-a]+dp[j])%MOD;
        else
            for(int j=-MAXS;j<=MAXS;j++)
                dp[j]=(dp[j-a]+dp[j])%MOD;
    }
    cout<<dp[s]%MOD;
    return 0;
}

4. NASA的⻝物计划

NASA（美国航空航天局）因为航天飞机的隔热瓦等其他安全技术问题一直大伤脑筋，因此在各方压力下终止了航天飞机的历史，但是此类事情会不会在以后发生，谁也无法保证，在遇到这类航天问题时，解决方法也许只能让航天员出仓维修，但是多次的维修会消耗航天员大量的能量，因此NASA便想设计一种食品方案，让体积和承重有限的条件下多装载一些高卡路里的食物.
航天飞机的体积有限，当然如果载过重的物品，燃料会浪费很多钱，每件食品都有各自的体积、质量以及所含卡路里，在告诉你体积和质量的最大值的情况下，请输出能达到的食品方案所含卡路里的最大值，当然每个食品只能使用一次.

#include<bits/stdc++.h>
using namespace std;
const int MAXN=5e2+8;
const int MAXV=4e2+8;
const int MAXW=4e2+8;
int n,vol,wt,v[MAXN],w[MAXN],c[MAXN],dp[MAXV][MAXW];
int main(){
    cin>>vol>>wt>>n;
    for(int i=1;i<=n;i++)
        cin>>v[i]>>w[i]>>c[i];
    for(int i=1;i<=n;i++)
        for(int j=vol;j>=v[i];j--)//体积
            for(int k=wt;k>=w[i];k--)//重量
                dp[j][k]=max(dp[j][k],dp[j-v[i]][k-w[i]]+c[i]);
    cout<<dp[vol][wt];
    return 0;
}