基础+进阶DP

背包问题

01背包问题

有 N件物品和一个容量是 V的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N]; 
int f[N][N];//从前i个物品中选，总体积不超过j的最大价值 

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=1;j<=m;j++)
	  {
   
	  	f[i][j]=f[i-1][j];
	     if(j>=v[i])  //放得下 
	     f[i][j]=max(f[i][j],f[i-1][j-v[i]]+w[i]); 
		}  
		cout<<f[n][m]<<endl;
		return 0;
}

优化从大到小循环

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int v[N],w[N];
int f[N];   
int main()
{
   
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
       cin>>v[i]>>w[i];
         //从前i-1中选，体积不超过j的最大价值
       
    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]; 

完全背包问题

有 N种物品和一个容量是 V的背包，每种物品都有无限件可用。
第 i 种物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 种物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
10

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int v[N],w[N]; 
int f[N][N];//从前i个物品中选，总体积不超过j的最大价值 

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++)
	   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;
		return 0;
}

优化 从小到大循环

#include<iostream>
using namespace std;

const int N=1010; 
int n,m;
int v[N],w[N],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];   
}

多重背包问题

有 N 种物品和一个容量是 V 的背包。第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤100
0<vi,wi,si≤100
输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=110;
int n,m;
int v[N],w[N],s[N]; 
int f[N][N];//从前i个物品中选，总体积不超过j的最大价值 

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*v[i]<=j&&k<=s[i];k++)
	     f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]); 
		 
		cout<<f[n][m]<<endl;
		return 0;
}

多重背包问题II

分组背包问题

有 N 组物品和一个容量是 V 的背包。
每组物品有若干个，同一组内的物品最多只能选一个。每件物品的体积是 vij，价值是 wij，其中 i是组号，j是组内编号。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。
接下来有 N组数据：
每组数据第一行有一个整数 Si，表示第 i个物品组的物品数量；每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤100
0<Si≤100
0<vij,wij≤100
输入样例
3 5
2
1 2
2 4
1
3 4
1
4 5
输出样例：
8

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=110;
int n,m;
int w[N][N],v[N][N],s[N]; 
int f[N];//从前i个物品中选，总体积不超过j的最大价值 

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]; //第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)//第i个物品组的第k个物品
	     f[j]=max(f[j],f[j-v[i][k]]+w[i][k]); 
		 
		cout<<f[m]<<endl;
		return 0;
}

线性DP

数字三角形模型

数字三角形

给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。

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

输入格式
第一行包含整数 n，表示数字三角形的层数。
接下来 n行，每行包含若干整数，其中第 i 行表示数字三角形第 i 层包含的整数。
输出格式
输出一个整数，表示最大的路径数字和。
数据范围
1≤n≤500,
−10000≤三角形中的整数≤10000
输入样例：
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
输出样例：
30

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N= 510,INF=1e9;
int f[N][N];  //所有从起点走到（i，j）点的路径 
int a[N][N];
int main()
{
   
	int n;
	cin>>n;
	for(int i=1;i<=n;i++) 
	 for(int j=1;j<=i;j++)
	    cin>>a[i][j];
	    
	for(int i=0;i<=n;i++) 
	 for(int j=0;j<=i+1;j++)
	   f[i][j]=-INF;  //处理边界
	   
	   f[1][1]=a[1][1];
	for(int i=2;i<=n;i++) 
	 for(int j=1;j<=i;j++) 
	   f[i][j]=max(f[i-1][j-1]+a[i][j],f[i-1][j]+a[i][j]);
	   
	int res=-INF;

	for(int i=1;i<=n;i++)    res=max(res,f[n][i]);
	cout<<res<<endl;
	return 0;   
}

摘花生

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;
const int N=1010;
int n,m;
int a[N][N],f[N][N]; 
int main()
{
   
	int t;
	cin>>t;

  while(t--)
   {
   
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	  for(int j=1;j<=m;j++)
	  cin>>a[i][j];
	  
	for(int i=1;i<=n;i++)
	  for(int j=1;j<=m;j++)
		f[i][j]=max(f[i-1][j],f[i][j-1])+a[i][j];
	
	cout<<f[n][m]<<endl;
   }
}

最低通行费

输入
5
1 4 6 8 10
2 5 7 15 17
6 8 9 18 20
10 11 12 19 21
20 23 25 29 33
输出
109

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;
const int N=1010,INF=1e8;
int n,m;
int a[N][N],f[N][N]; 
int main()
{
   


	cin>>n;
	for(int i=1;i<=n;i++)
	for(int j=1;j<=n;j++)
	  cin>>a[i][j];
	 
	for(int i=1;i<=n;i++)
	for(int j=1;j<=n;j++)
	{
   
		if(i==1&&j==1)  f[i][j]=a[i][j];//特判左上角
	  else
	  {
   
	     f[i][j]=INF;
	     if(i>1)  f[i][j]=min(f[i][j],f[i-1][j]+a[i][j]);//不在第一行，才可以从上面过来
	     if(j>1)  f[i][j]=min(f[i][j],f[i][j-1]+a[i][j]);
    	}
	}
	cout<<f[n][n]<<endl;
   
}

方格取数

最长上升序列模型

最长上升子序列

给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。
输入格式
第一行包含整数 N。
第二行包含 N 个整数，表示完整序列。
输出格式
输出一个整数，表示最大长度。
数据范围
1≤N≤1000，
−109≤数列中的数≤109
输入样例：
7
3 1 2 1 8 5 6
输出样例：
4

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;
const int N=1010;
int f[N];  //以第i个数结尾的上升子序列集合 
int a[N];
int main()
{
   
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)  cin>>a[i]; 

    for(int i=1;i<=n;i++)
    {
   
    	f[i]=1;   //只有a[i]一个数 
    	for(int j=1;j<i;j++)
    	if(a[j]<a[i])
    	  f[i]=max(f[i],f[j]+1);
	}
	int res=0;
	for(int i=1;i<=n;i++)   res=max(res,f[i]);
	
	cout<<res<<endl;
	
}

输出方案数

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;
const int N=1010;
int f[N];  //以第i个数结尾的上升子序列集合 
int a[N],g[N]