2019牛客暑期多校训练营（第五场）部分

Ο

.

题号

A

B

C

D

E

F

G

H

I

J

K

L

状态

Ο

.

.

.

.

.

Ο

.

.

.

.

.

A：思维，输出n次n叠加即可

B：10进制矩阵快速幂，不会矩阵  咕咕咕

 

G：dp

最初想的比较好理解的dp是 

dp[i][j][k]，处理到第i位，长度位j，首位是k的满足题意子序列的方案数。

dp2[i][j][k],处理到第i位，长度位j，首位是k的任意子序列的方案数。

递推很简单，从i从n-1扫描，dp2肯定是由前一位，选第i位和不选第i位转移

dp分为当前位是否大于对应的t串位置（从后往前，长度为j）。大于则由dp2 递推

否则由dp递推（dp维护的一定是严格大于，即处理了j位是严格大于对应后缀t，j位的）

 

上述递推过程想明白就会发现，第三位k完全没必要，

dp2可以用组合数表示

然后用滚动数组思想可以把第一位给去掉

就得到如下代码。

#include 
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair pii;
typedef pair pll;
typedef pair pdd;
#define F first
#define S second
const ll INF64=8000000000000000000LL;
const int INF=0x3f3f3f3f;
const ld PI=acos(-1);
const ld eps=1e-9;
const ll MOD=ll(998244353);
const int M = 3e3 + 10;
void modup(ll&x){if(x>=MOD)x-=MOD;}
//unordered_mapmp;
ll dp[M];//到i，长度j，满足a>b方案
char a[M],b[M];
ll c[M][M],sc[M][M];
void dabiao()
{
    for (int i=1;i<=3000;i++)
    {
        c[i][0]=1;
        c[i][i]=1;
        for (int j=1;j>t;
    dabiao();
    while(t--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        scanf("%s%s",a+1,b+1);
        for(int j=0;j<=m;j++)
            dp[j]=0;
        ll ans=0;
        dp[1]=(a[n]>b[m]);
        for(int i=n-1;i>=1;i--)
        {
            for(int j=min(m,n-i+1);j>=1;j--)
            {
               // dp[j]+=dp[j],modup(dp[j]);
                if(a[i]>b[m-j+1])//如果i位  a更大  ，可以由长度j-1任意首位递推
                    dp[j]+=c[n-i][j-1],modup(dp[j]);
                else if(a[i]==b[m-j+1])
                    dp[j]+=dp[j-1],modup(dp[j]);
               // printf("%d-- %d --  %d\n",i,j,dp[j]);
            }
            //ans+=dp[i][m];modup(dp[i][m]);
        }
        ans+=dp[m],modup(dp[m]);
        for(int i=1;i<=n-m;i++)
        {
            if(a[i]>'0')
            {
                for(int j=m;j<=n-i;j++)
                ans=(ans+c[n-i][j])%MOD;
            }
        } 
        modup(ans);
        printf("%lld\n",ans);
    }
    return 0;
}