动态规划-蓝桥杯

介绍

基本概念：

例一

#include<iostream>
#include<algorithm>
using namespace std;
int a[110][110];
int dp[110][110];
int main(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++)
		{
			cin>>a[i][j];
		}
	}
	dp[1][1]=0;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++)
		{
			if(i==1 && j==1){
				continue;
			}else if(i==1){
				dp[i][j]=dp[i][j-1] + a[i][j];
			}else if(j==1){
				dp[i][j]=dp[i-1][j] + a[i][j];
			}else{
				dp[i][j]=min(dp[i-1][j],dp[i][j-1])+a[i][j];
			}
		}
	}
	cout<<dp[n][n]<<endl;
}

例二

#include<iostream>
using namespace std;
const int N =1e3+9;
const int inf=10000000000;

int f[N][N];
int main()
{
	int n;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=i;j++){
			cin>>f[i][j];
		}
	}
	
	int ma=-inf;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=i;j++){
			f[i][j]+=max(f[i-1][j],f[i-1][j-1]);
			if(i==n){
				ma=max(f[i][j],ma);
			}
		}
	}
	if(ma==-inf){
		ma=0;
	}
	cout<<ma<<endl;
 } 

例三

#include<iostream>
using namespace std;
const int N=1e2+9;
const int inf=1000000000;

int f[N][N][N];
int main(){
	int x,y,z;
	cin>>x>>y>>z;
	for(int i=0;i<=x;i++){
		for(int j=0;j<=y;j++){
			for(int k=0;k<=z;k++){
				cin>>f[i][j][k];
			} 
		} 
	}
	
	for(int i=0;i<=x;i++){
		for(int j=0;j<=y;j++){
			for(int k=0;k<=z;k++){
				int mi=inf;
				if(i!=0){//注意边界问题 
					mi=min(mi,f[i-1][j][k]);
				}
				if(j!=0){
					mi=min(mi,f[i][j-1][k]);
				} 
				if(k!=0){
					mi=min(mi,f[i][j][k-1]);
				}
				if(mi!=inf){
					f[i][j][k] += mi;
				}
			} 
		} 
	}
	//起点未更新 
	cout<<f[x][y][z]<<endl;
	return 0;
}

1.

思路：从最后一步开始往前推，第n个台阶的所有方法为=第n-1个台阶的所有方法+第n-1个台阶的所有方法，因为想到达第n个的台阶只能通过：到达第n-1个台阶再跨一步或者到达第n-2个台阶时再跨两步。

#include<iostream>
#include<cstdio>
using namespace  std;
int dp[1010];
const int mod=100007;
int main(){
	int n;
	cin>>n;
	dp[0]=dp[1]=1;
	for(int i=2;i<=n;i++)
	{
		dp[i]=(dp[i-1]+dp[i-2]) % mod;
	 } 
	 cout<<dp[n]<<endl;
	 return 0;
} 

2.

#include<iostream>
#include<cstdio>
using namespace  std;
int dp[1010];
const int mod=100007;
int main(){
	int n;
	cin>>n;
	dp[0]=1;
	for(int i=1;i<=n;i++){
		dp[i]=0;
		for(int j=i-1;j>=0;j-=2){
			dp[i]+=dp[j];
			dp[i] %=mod;
		}
	} 
	 cout<<dp[n]<<endl;
	 return 0;
} 

3.

思路：到了第i个弹簧板后，还需要多少步才能被弹出界外

#include<iostream>
#include<cstdio>
#include<cstring> 
using namespace  std;
const int maxn=100010; 
int a[maxn],dp[maxn];
int main(){
	int n;
	cin>>n;
    memset(dp,0,sizeof(dp));
    for(int i=1;i<=n;i++)
    {
    	cin>>a[i];
	}
	int ans;
	for(int i=n;i>=1;--i){
		dp[i]=dp[i+a[i]]+1;
		ans=max(ans,dp[i]);
	}
	cout<<ans<<endl;
	return 0;
}  

4.

思路：传了多少次，在谁的手上，用的步数

#include<iostream>
#include<cstring> 
using namespace std;
int f[999][999];
int main(){
	int n,m;
	cin>>n>>m;
	memset(f,0,sizeof(f));
	f[0][1]=1;
	for(int i=1;i<=m;i++){
		for(int j=1;j<=n;j++)
		{
			if(j==1){
				f[i][j]=f[i-1][2]+f[i-1][n];
			}else if(j==n){
				f[i][j]=f[i-1][1]+f[i-1][n-1];
			}else{
				f[i][j]=f[i-1][j-1]+f[i-1][j+1];
			}
		}
	}
	cout<<f[m][1]<<endl;
	return 0;
}

5.

思路：只考虑最后一组，前n个数的最大权值为：max( 前个i数的最大权值 + pre[i+1][n] 这一区间的权值)

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=1010;
const int mod=1000;
int a[maxn];
int dp[maxn];
int pre[maxn][maxn];
int main()
{
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>a[i];
	 } 
	for(int i=1;i<=n;++i)
	{
		pre[i][i]=a[i];
		for(int j=i+1;j<=n;++j)
		{
			pre[i][j]=pre[i][j-1]*a[j] % mod;
		}
	}
	dp[0]=0;
	dp[1]=a[1];
	for(int i=2;i<=n;++i)
	{
		for(int j=0;j<i;++j)
		{
			dp[i]=max(dp[i],dp[j]+pre[j+1][i]);
		}
	}
	cout<<dp[n]<<endl;
	return 0;
 } 

二、常见动态规划模型

2.1 最大子段和

#include<iostream>
#include<algorithm>
using namespace std;
const int inf=0x7ffffff;
int main()
{
	int N;
	int num[99999];
	cin>>N;
	for(int i=0;i<N;i++){
		cin>>num[i];
	} 
	int ans=-inf;
	for(int i=0;i<N;i++){
		ans=max(ans,num[i]);
	}
	if(ans<=0)
	{
		cout<<ans<<endl;
	 }else{
	 	int sum=0;
	 	for(int i=0;i<N;i++){
	 		if(sum+num[i]<0){
	 			sum=0;
			 }else{
			 	sum+=num[i];
			 }
			 ans=max(ans,sum);
		 }
	 }
	 
	cout<<ans<<endl;
 } 

2.2 最长上升子序列

#include<iostream>
#include<cstring>
using namespace std;
int dp[101],a[101],n;
int LIS()
{
	int ans=0;
	for(int i=1;i<=n;i++){
		dp[i]=1;
		for(int j=1;j<i;j++)
		{
			if(a[j]<a[i])
			dp[i]=max(dp[i],dp[j]+1);
		}
		ans=max(ans,dp[i]);
	}
	
	return ans;
}

int main()
{
    cin>>n;
	for(int i=0;i<n;i++){
		cin>>a[i];
	}	
	cout<<LIS()<<endl;
	return 0;
 } 

2.3 最长公共子序列

举一个例子，两个序列 S1= abcfbc 和 S2=abfcab，根据转移方程可以得出lcs[i][j]

#include<iostream>
#include<cstring>
#include<string> 
using namespace std;
int dp[110][110];
int main()
{
	string a,b;
	memset(dp,0,sizeof(dp));
	cin>>a>>b;
	int lena=a.size();
	int lenb=b.size();
	for(int i=1;i<=lena;i++){
		for(int j=1;j<=lenb;j++){
			if(a[i-1]==b[j-1])
			{
				dp[i][j]=dp[i-1][j-1]+1;
			}else{
				dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
			}
		}
	}
	cout<<dp[lena][lenb]<<endl;
}

2.4 编辑字符

#include<iostream>
#include<cstring>
#include<string> 
using namespace std;
int dp[110][110];
string a,b;
int main()
{
	cin>>a>>b;
	int lena=a.size();
	int lenb=b.size();
	
	//边界处理 
	
	for(int i=1;i<=lena;i++)
	{
		dp[i][0]=i;
	 }
	  
	 for(int i=1;i<=lenb;i++)
	{
		dp[0][i]=i;
	 } 
	 
	//为了下标出现负号，因此下标从一开始，
	//但为了和数组匹配，进行调整 
	for(int i=1;i<=lena;i++){
		for(int j=1;j<=lenb;j++){
			if(a[i-1]==b[j-1])
			{
				dp[i][j]=dp[i-1][j-1];
			}else{
				dp[i][j]=min(  min(dp[i][j-1],dp[i-1][j]) ,dp[i-1][j-1] ) + 1;
			}
	}
	} 
	cout<<dp[lena][lenb]<<endl;
	return 0;		
}

三、练习

3.1 回文数–最长公共子序列问题

思路，将原字符串反过来，再将其和原字符串求最长公共子序列，就可以知道有几个顺序已经一样，剩余的就是得操作的。

#include<iostream>
#include<string>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;

string s1,s2;
int dp[3005][3005];

int main(){
	cin>>s1;
	s2=s1;
	reverse(s2.begin(),s2.end());
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=s1.size();i++){
		for(int j=1;j<=s2.size();j++){
			if(s1[i-1]==s2[j-1]){
				dp[i][j]=dp[i-1][j-1]+1;
			}else{
				dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
			}
		} 
	}
	cout<<s1.size()-dp[s1.size()][s2.size()]<<endl;
	return 0;
}