给出 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;
}