2021CCPC网络赛 F. Nun Heh Heh Aaaaaaaaaaa题型详细讲解+leetcode115不同的子序列

补题链接

主要思路

动态规划+快速幂+后缀和

复杂的O（n）

详细内容请看代码注解

先不考虑a，先算芳香字符串非a个数，最后个数乘以2的a个数次方-1，相加取模。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e5+5;
typedef long long LL;
int dp[10][N];
int a[N];//a的后缀数量
const int mod = 998244353;


//预处理后缀中a的个数
void init(string s)
{
    memset(a,0,sizeof a);
    for(int i=s.size();i>=1;i--)
    {
        a[i]=a[i+1]+(s[i]=='a');
    }
}
// 这里别不小心用了龟速乘，我刚才不小心用了龟速乘一直TLE
//后面有几个a，每个a可以选也可以不选所以是2的a次方，但a个数不能为0所以-1
LL qmi(int b)
{
    LL res=1%mod;
    LL a=2;
    while(b){
        if(b&1)res=res*a%mod;
        a=a*a%mod;
        b>>=1;

    }
    return (res-1)%mod;
}
int main()
{
    std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
    int T;
    cin>>T;
    while(T--)
    {
        string s;
        cin>>s;
        //使下标从1开始
        s=" "+s;
        init(s);
        
        //string ss=" nunhehheh";
        
        //dp过程 nunhehheh
        //dp[j][i]表示s前i个字符中ss[1~j]字符串出现次数
        LL res=0;
        for(int i=1;i<=s.size();i++)
        {
            dp[1][i]=(dp[1][i-1]+(s[i]=='n'))%mod;
            dp[2][i]=(dp[2][i-1]+dp[1][i-1]*(s[i]=='u'))%mod;
            dp[3][i]=(dp[3][i-1]+dp[2][i-1]*(s[i]=='n'))%mod;
            dp[4][i]=(dp[4][i-1]+dp[3][i-1]*(s[i]=='h'))%mod;
            dp[5][i]=(dp[5][i-1]+dp[4][i-1]*(s[i]=='e'))%mod;
            dp[6][i]=(dp[6][i-1]+dp[5][i-1]*(s[i]=='h'))%mod;
            dp[7][i]=(dp[7][i-1]+dp[6][i-1]*(s[i]=='h'))%mod;
            dp[8][i]=(dp[8][i-1]+dp[7][i-1]*(s[i]=='e'))%mod;
            dp[9][i]=(dp[8][i-1]*(s[i]=='h'))%mod;
            if(dp[9][i])res=res%mod+(dp[9][i]*qmi(a[i+1]))%mod;
            res%=mod;
        }
        cout<<res<<endl;
    }
}

分享leetcode相似题目

115.不同的子序列

题目链接

(动态规划) O(nm)

可以换一种考虑问题的方式：用S中的字符，按顺序匹配T中的字符，问有多少种方式可以匹配完T 中的所有字符。

可以用动态规划来做：
f[i][j] 表示用 S 的前 i个字符，能匹配完T 的前j个字符的方案数。
初始化：因为 S 可以从任意一个字符开始匹配，所以 f[i][0]=1,∀i∈[0,len(S)]。
状态转移：

如果 S[i−1]≠T[j−1]，则 S[i−1]不能匹配 T[j−1]，所以f[i][j]=f[i−1][j]；
如果 S[i−1]=T[j−1]，则 S[i−1] 既可以匹配 T[j−1]，也可以不匹配 T[j−1]，所以 f[i][j]=f[i−1][j]+f[i−1][j−1]；
时间复杂度分析：假设 S的长度是n，T 的长度是 m，则共有 nm 个状态，状态转移的复杂度是 O(1)，所以总时间复杂度是 O(nm)。
题解 摘自yxc
作者：yxc
来源：AcWing

class Solution {
public:
    int numDistinct(string s, string t) {
        int n=s.size(),m=t.size();
        vector<vector<unsigned long long>>f(n+1,vector<unsigned long long>(m+1));
        for(int i=0;i<=n;i++)f[i][0]=1;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                f[i][j]=f[i-1][j];
                if(s[i-1]==t[j-1])
                f[i][j]+=f[i-1][j-1];
            }
        }
        return f[n][m];
    }
};