题型归纳5-dp操作

题目1
Contest Setting 选题

给出 N个题目，每个题目都有一定难度，从中选取K个题，要求K个题的难度都不能重复，问有多少种选择方法，结果取余。

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e3+5;
const int mod=998244353;
long long num[maxn],dp[maxn];
map<long long,long long>mp;
int cnt=0;
int main()
{
	long long n,k;
	cin>>n>>k;
	for(int i=1;i<=n;i++){
		int x;
		cin>>x;
		if(mp[x]==0)
		{ 
			mp[x]=++cnt;//cnt记录出现过的等级的种类树，mp[x]表示自己是第几种难度的题！ 
		}//给每种题进行编号！ 
		
		
		num[mp[x]]++;//vis记录 每个等级拥有的题的数量！！！！ 
		//记录每个等级的题拥有的数量！ 
	}
	dp[0]=1;
	///    
	///   每种等级的题都可能被选，最多选k个！ 
	for(int i=1;i<=cnt;i++){//一共又 cnt 种等级！ //每次不能选择同等级的东西！ 
		for(int j=k;j>=1;j--){//倒叙就是为了控制每次只能这个等级的一道题！！！ 
		
		
		//每次选k个！！！ //控制每个等级一次性只能选择一道题 
			dp[j]=(dp[j]+(dp[j-1]*num[i])%mod)%mod;
			//dp[1]=dp[1]+dp[0]*num[1];
			
		
			//dp[2]=dp[2]+dp[1]*num[2];
			
			
			//dp[3]=dp[3]+dp[2]*num[3]; 
		}
	}
	cout<<dp[k];
	return 0;
}

首先用map给每个难度的题进行编号,统计一共有多少种不同的难度！

然后用num统计每种难度的题的数量

由于每种难度的题只能选择一次，所以类似于0 1背包
每种题都有被选择的机会，但是每种题仅仅能被选择一次

for(int i=1;i<=cnt;i++) 表示每种题都有选择机会

for(int j=k;j>=1;j–) 表示选择k种题，并且每种题只能选择一次

类似于0 1背包

dp[j]=(dp[j]+(dp[j-1]*num[i])%mod)%mod;

表示把选择 (j-1)道题的状态转移到 选择 j 道题上！

选择 j 道题就是在选择 j-1道题的基础上，再选择一道题

所以 dp[j]=dp[j-1]*num[i]

题目2
爬塔问题

有n个台阶
初始时，在1号台阶
每个台阶的纵坐标与其编号相同
横坐标由输入给出

每次我们可以最多跳越k层台阶，
但是相应的会付出 |x1−x2|+(y1−y2)^2的代价

问从1号台阶跳到n号台阶所需要付出的最小代价是多少

误区
我最开始的思路是想dfs，然后求出最少的代价
但是这样的复杂度已经超级爆表了
这样每一种路径都要判断一次，直接废了

但是我们使用dp，每次只对到达这一层的最小时间进行存储，
然后再利用本层的最小时间，算出上面层数的时间，分别取最小时间存储，然后再重复上述操作即可。
最后dp[n]就是到达最后一层的最短时间

#include<bits/stdc++.h>
using namespace std;
long long t[100001];
long long time(int x1,int x2,int y1,int y2)//求代价！！！！求代价！ 
{
	return abs(x1-x2)+(y1-y2)*(y1-y2);
}
long long dp[100001];//存储当前节点到达的最小值！
int main()
{
	int n,k;
	cin>>n>>k;
	
	for(int i=1;i<=n;i++)
	{
		cin>>t[i];//X坐标！  
	}
	
	for(int i=1;i<=n;i++)
	  for(int j=i+1;j<=i+k;j++)//表示从点i跳到点j,j表示的是i能跳越的范围！ 
	  {
	  	if(j<=n)//如果不超界的话！！！ 
	  	{
	  		if(dp[j]==0)//这个点没达到过！   //本题核心！！ 
	  		{
	  		  dp[j]=dp[i]+time(t[j],t[i],j,i);	
			}
			else//这个点已经到达过了！！！！ 
			{
				dp[j]=min(dp[j],dp[i]+time(t[j],t[i],j,i));
			}
		}
	  }
	  
	  cout<<dp[n];
	  return 0;
}

题目3
nunhehheh字符串

定义一个字符串如果前缀是 nunhehheh 后缀至少有一个a的时候
就是 一个芳香字符串

现在给出一个字符串，问其中有多少个芳香子序列（可以不连续）

原理
如果当前只有一个前缀，而后面有很多个a的情况下
如下
aaaaa前缀aaaaaa
那我们就要统计从 当前前缀-末尾一共有多少个a，
每一个a都可以选择删除或者不删除 两种情况！
假设前缀后面有n个a，那么就有 2^n-1个子序列

所以我们首先要进行对a处理
处理出 从字符串第 i-n一共有多少个a。

这样我们每判断出一个前缀，就把最终答案+= 前缀数*2^n-1;
n为从当前位置到末尾的a的数量

然后观察前缀的规律
nunhehheh
n只出现在1 3位
u出现在2位
h出现在4 6 7 9位
e 出现在 5 8位

从头到尾查找字符串
遇到n
dp[0]++;
dp[2]+=dp[1];
遇到u
dp[1]+=dp[0]
遇到e
dp[5]+=dp[4]
dp[8]+=dp[7]
遇到h
dp[4]+=dp[3]
dp[6]+=dp[5]
dp[7]+=dp[6]

就这样一点一点的把dp[1]的值传递给 dp[8]！

最后如果再遇到h
说明一个前缀可能已经被凑出来了
此时，dp[8]的值就是 从起始到目前为止的 残缺前缀（去掉一个h) 的数量

然后每次再次遇到h
这个缺h的前缀都可以和字母h组成一个完整前缀，
然后用这个完整前缀*2^n-1(n为后面a的数量）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5;
int flag=0;
ll dp[maxn];/判断后缀！ 
ll dp2[maxn];///判断前缀！ 
char s[maxn]; ll sum=0;
ll mod=998244353;
ll fastme(ll x,ll n,ll mod){//快速幂！   
	ll ans=1;
	x%=mod;
	while(n){
		if(n&1) ans=(ans*x)%mod;
		x=(x*x)%mod;
		n/=2ll;
	}
	return ans%mod;
}
void solve(){//


 
	int len=strlen(s);
	if(s[len-1]=='a')
	dp[len-1]=1;
	
	for(int i=len-2;i>=0;i--){
		if(s[i]=='a') 
		dp[i]=dp[i+1]+1;     
		else 
		dp[i]=dp[i+1];
	}
	for(int i=0;i<len;i++){
		if(s[i]=='n'){
			dp2[0]++;
			dp2[2]+=dp2[1];
			
			dp2[0]%=mod;
			dp2[2]%=mod;
		}
		else if(s[i]=='u'){
			dp2[1]+=dp2[0];	
			dp2[1]%=mod; 
		}
		else if(s[i]=='h'){
			dp2[3]+=dp2[2];
			dp2[6]+=dp2[5];
			dp2[5]+=dp2[4]; 
			
			
			dp2[6]%=mod;dp2[5]%=mod;dp2[3]%=mod; 
			sum=(sum+dp2[7]*(fastme(2,dp[i],mod)-1))%mod; 
		}
		else if(s[i]=='e'){
			dp2[7]+=dp2[6];
			
			
			dp2[4]+=dp2[3];
			dp2[4]%=mod;dp2[7]%=mod; 
		}
	}
}
int main(){
	int r; 
	scanf("%d",&r);
	while(r--){
		memset(dp,0,sizeof(dp));
		memset(dp2,0,sizeof dp2);
		sum=0;
		scanf("%s",s);
		//cout<<s<<endl;
		solve();
		printf("%lld\n",sum);
	}
	return 0; 
}