dp学习ing

动态规划学习

01背包

其从后向前更新是为了使得最大值能更新和前边的物品加起来

//#pragma GCC optimize(1)
//#pragma GCC optimize(2)
//#pragma GCC optimize(3,"Ofast","inline")
#define buff  ios::sync_with_stdio(false);
#define gcd __gcd
#define debug() printf("***\n")
#define zero(a) memset(a,0,sizeof(a))
#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#include<numeric>
#include<math.h>
#include<list>
#include<bitset>
#include<vector>
#include<utility>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=1010;
int dp[maxn],w[maxn],v[maxn];
int main()
{
	int n,m;
	scanf("%d%d",&n,&m);
	zero(dp);
	for(int i=0;i<n;i++)
	{
		scanf("%d%d",&v[i],&w[i]);
	}
	for(int i=0;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]);
}

完全背包

背包物品无限，因此从前向后更新，模拟物品一个一个的装进去

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#include<numeric>
#include<math.h>
#include<list>
#include<bitset>
#include<vector>
#include<utility>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
const int maxn=1010;
int w[maxn],v[maxn];
int dp[maxn];
int main()
{
	memset(dp,0,sizeof(dp));
	int m,n;
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++)
	{
		scanf("%d%d",&v[i+1],&w[i+1]);
	}
	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]);
}

多重背包

物品价值，个数，容量都有限制

可以将多重背包拆分成多个零一背包进行求解

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#define buff  ios::sync_with_stdio(false);
#define gcd __gcd
#define debug printf("***\n")
#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#include<numeric>
#include<math.h>
#include<list>
#include<bitset>
#include<vector>
#include<utility>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=11000;
int v[maxn],w[maxn],dp[maxn];
int s;
int main()
{
	int n,m;
	memset(dp,0,sizeof(dp));
	scanf("%d%d",&n,&m);
	int p=0;
	for(int i=0;i<n;i++)
	{
		int vv,ww;
		scanf("%d%d%d",&vv,&ww,&s);
		while(s--)
		{
			v[p]=vv;
			w[p]=ww;
			p++;
		}
	}
	for(int i=0;i<p;i++)
	{
		for(int j=m;j>=v[i];j--)
		{
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
		}
	}
	printf("%d",dp[m]);
	
}

多重背包的优化

二进制优化

二进制优化的思想还是很巧妙的，根据c【i】（次数）得到一组这样的数 2^0,21,2^2,23…2^(k-1) , c-2^k+1 其中k是满足2^{k小于c的最大值，就像c=7=111，2}k=100=4 ;

**c=9=1001, 2^k=1000=8 ; c=8=1000 2^k=0100=4 **

得到这组数的目的是什么呢，

1到c之间的所有数都可以由这组数组合得到（选取相加），而从这组数里任意选任意个（每个数最多只能选一次）加在一起得到的数也必定是1~c这个闭区间内的

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#define buff  ios::sync_with_stdio(false);
#define gcd __gcd
#define debug printf("***\n")
#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#include<numeric>
#include<math.h>
#include<list>
#include<bitset>
#include<vector>
#include<utility>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=11000;
int v[maxn],w[maxn],dp[maxn];
int s;
int main()
{
	int n,m;
	memset(dp,0,sizeof(dp));
	scanf("%d%d",&n,&m);
	int p=0;
	for(int i=0;i<n;i++)
	{
		int vv,ww;
		scanf("%d%d%d",&vv,&ww,&s);
		queue<int> Q;
		int q=1;
		while(q<=s)
		{
			Q.push(q);
			s-=q;
			if(q<=s)
			{	
				q*=2;
			}
		}
		if(s>0)
		{
			Q.push(s);
		}
		while(!Q.empty())
		{
			q=Q.front();
			w[p]=q*ww;
			v[p]=q*vv;
			p++;
			Q.pop();
		}
	}
	for(int i=0;i<p;i++)
	{
		for(int j=m;j>=v[i];j--)
		{
			dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
		}
	}
	printf("%d",dp[m]);
	
}

单调队列优化

。。。。。。

分组背包

有 N 组物品和一个容量是 V 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。

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

对于每一个位置上枚举组内的物品更新最大值

从后向前更新避免上一次的状态被覆盖，从而可以使用上一次保存的状态

#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#define buff  ios::sync_with_stdio(false);
#define gcd __gcd
#define debug printf("***\n")
#include<stdio.h>
#include<string.h>
#include<string>
#include<iostream>
#include<algorithm>
#include<numeric>
#include<math.h>
#include<list>
#include<bitset>
#include<vector>
#include<utility>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=110;
int v[maxn][maxn],w[maxn][maxn],dp[maxn],s[maxn];
int main()
{
	int n,m;
	memset(dp,0,sizeof(dp));
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++)
	{
		scanf("%d",&s[i]);
		for(int j=0;j<s[i];j++)
		{
			scanf("%d%d",&v[i][j],&w[i][j]);
		}
	}
	for(int i=0;i<n;i++)
	{
		for(int j=m;j>=0;j--)
		{
			for(int k=0;k<s[i];k++)
			{
				if(j>=v[i][k])
				dp[j]=max(dp[j],dp[j-v[i][k]]+w[i][k]);
			}
		}
	}
	printf("%d",dp[m]);
}