洛谷P2679 [NOIP2015]子串【DP】

时空限制 1000ms / 128MB

题目描述

有两个仅包含小写英文字母的字符串 A 和 B。

现在要从字符串 A 中取出 k 个互不重叠的非空子串，然后把这 k 个子串按照其在字符串 A 中出现的顺序依次连接起来得到一个新的字符串。请问有多少种方案可以使得这个新串与字符串 B 相等？

注意：子串取出的位置不同也认为是不同的方案。

输入格式：

第一行是三个正整数 n,m,k，分别表示字符串 A 的长度，字符串 B 的长度，以及问题描述中所提到的 k，每两个整数之间用一个空格隔开。

第二行包含一个长度为 n 的字符串，表示字符串 A。
第三行包含一个长度为 m 的字符串，表示字符串B。

输出格式：

一个整数，表示所求方案数。
由于答案可能很大，所以这里要求输出答案对 1000000007 取模的结果。

说明

对于第 1 组数据:1≤n≤500,1≤m≤50,k=1
对于第 2 组至第 3 组数据:1≤n≤500,1≤m≤50,k=2
对于第 4 组至第 5 组数据:1≤n≤500,1≤m≤50,k=m
对于第 1 组至第 7 组数据:1≤n≤500,1≤m≤50,1≤k≤m
对于第 1 组至第 9 组数据:1≤n≤1000,1≤m≤100,1≤k≤m
对于所有 10 组数据:1≤n≤1000,1≤m≤200,1≤k≤m

题目分析

$dp[i][j][k][0/1]$ 表示考虑A串前 $i$ 个字符，匹配到B串第 $j$ 个字符
已经选出 $k$ 个子串，且A的第 $i$ 个字符是否选的方案数

转移方程不难想

dp[i][j][k][0]=dp[i-1][j][k][0]+dp[i-1][j][k][1];
if(A[i]==B[j]) dp[i][j][k][1]=dp[i-1][j-1][k-1][1]+dp[i-1][j-1][k-1][0]+dp[i-1][j-1][k][1];

坑点在于空间限制
注意到每次 $dp[i][][][]$ 都只从 $dp[i-1][][][]$ 转移，所以第一维可以滚动数组优化
即交替使用第0维和第1维

#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
#include<cstring>
#include<cstdio>
using namespace std;
typedef long long lt;
  
int read()
{
    int f=1,x=0;
    char ss=getchar();
    while(ss<'0'||ss>'9'){if(ss=='-')f=-1;ss=getchar();}
    while(ss>='0'&&ss<='9'){x=x*10+ss-'0';ss=getchar();}
    return f*x;
}

const lt mod=1000000007;
const int maxn=1010;
int n,m,K;
lt dp[2][210][210][2];
char A[maxn],B[maxn];

int main()
{
    n=read();m=read();K=read();
    scanf("%s%s",&A,&B);
    dp[0][0][0][0]=1;
    for(int i=1;i<=n;++i)
    {
        dp[i&1][0][0][0]=1;
        for(int j=1;j<=m;++j)
        for(int k=1;k<=K;++k)
        {
            dp[i&1][j][k][0]=(dp[(i-1)&1][j][k][0]+dp[(i-1)&1][j][k][1])%mod;
            dp[i&1][j][k][1]=(A[i-1]==B[j-1])*(dp[(i-1)&1][j-1][k-1][1]+dp[(i-1)&1][j-1][k-1][0]+dp[(i-1)&1][j-1][k][1])%mod;
        }
    }
    printf("%lld",(dp[n&1][m][K][0]+dp[n&1][m][K][1])%mod);
    return 0;
}