Luogu [NOIP2015 提高组] 子串

P2679 [NOIP2015 提高组] 子串

[NOIP2015 提高组] 子串

题目背景

NOIP2015 Day2T2

题目描述

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

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

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

输入格式

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

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

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

输出格式

一个整数，表示所求方案数。

由于答案可能很大，所以这里要求输出答案对 $1000000007$ 取模的结果。

样例 #1

样例输入 #1

6 3 1 
aabaab 
aab

样例输出 #1

2

样例 #2

样例输入 #2

6 3 2 
aabaab 
aab

样例输出 #2

7

样例 #3

样例输入 #3

6 3 3 
aabaab 
aab

样例输出 #3

7

数据范围

对于第 1 组数据：$1\le n\le 500,1\le m\le 50,k=1$;
对于第 2 组至第 3 组数据：$1\le n\le 500,1\le m\le 50,k=2$;
对于第 4 组至第 5 组数据：$1\le n\le 500,1\le m\le 50,k=m$;
对于第 1 组至第 7 组数据：$1\le n\le 500,1\le m\le 50,1\le k\le m$;
对于第 1 组至第 9 组数据：$1\le n\le 1000,1\le m\le 100,1\le k\le m$;
对于所有 10 组数据：$1\le n\le 1000,1\le m\le 200,1\le k\le m$。

思路

设计状态捏

用i，j两维表示现在匹配的是A串的前i个字符，B串的前b个字符

加一个k表示已经匹配了k个串
$$f[i][j][k]:A串的前i个字符与B串的前j个字符匹配k个串的方案数$$
那可以想到，分为当前这个字符A[i]用/不用可以有转移方程：
$$f[i][j][k]=f[i-1][j-1][k-1]+f[i-1][j-1][k]$$
但是这个方程不能确定使用A[i]是单独作为一个一个串还是和前面相连，

可以再加一个维度0/1表示是否使用这个字符

有两个情况：

• $$f[i][j][k][0]=f[i-1][j][k][0]+f[i-1][j][k][1]$$

• 如果满足A[i] = B[j]:
  $$\begin{gathered} f[i][j][k][1]=f[i-1][j-1][k-1][0](第i位使用，第i-1位置不用) \\ +f[i-1][j-1][k][1](第i位和第i-1位相连使用) \\ +f[i-1][j-1][k-1][1](第i位和第i-1位断开使用) \end{gathered}$$

然后考虑初始状态即j = k = 1的情况

可以知道A[1] -> A[i]中有几个字符 = B[1]即有几个方案

贴个Code，滚动压掉了i的维度

#include <cstdio>
#include <iostream>
#include <algorithm>
#define Maxn 1005
#define Maxm 205
using namespace std;
const int Mod = 1000000007;
int n,m,k;
int f[3][Maxm][Maxm][2];
char a[Maxn],b[Maxm];
int main(){
    cin >> n >> m >> k;
    scanf("%s %s",a + 1,b + 1);
    int sum = 0;
    f[0][0][0][0] = 1;
    f[1][0][0][0] = 1;
    for(int i = 1,op = 1;i <= n;i ++,op = op ^ 1){
        for(int j = 1;j <= m;j ++)
            for(int t = 1;t <= k;t ++){
                if(a[i] == b[j]){
                    f[op][j][t][0] = (f[op ^ 1][j][t][1] + f[op ^ 1][j][t][0]) % Mod;
                    f[op][j][t][1] = (f[op ^ 1][j - 1][t - 1][0] + f[op ^ 1][j - 1][t - 1][1] + f[op ^ 1][j - 1][t][1]) % Mod;
                }
                else{
                    f[op][j][t][0] = (f[op ^ 1][j][t][1] + f[op ^ 1][j][t][0]) % Mod;
                    f[op][j][t][1] = 0;
                }
                
            }
    }
    cout << (f[n & 1][m][k][0] + f[n & 1][m][k][1]) % Mod << endl;
    return 0;
}