NOIP2015提高组第二轮day2

NOIP2015提高组第二轮day2 - T2：子串

news2024/11/29 9:46:10

题目链接

[NOIP2015 提高组 day2 第二题] 子串

题目描述

有两个仅包含小写英文字母的字符串 $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

6 3 2 
aabaab 
aab

样例输出 #2

样例 #3

样例输入 #3

6 3 3 
aabaab 
aab

样例输出 #3

提示

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

算法思想（朴素版动态规划，70分）

状态表示：f[i][j][k]表示从字符串 $A$ 的前i个字符中取出 k 个互不重叠的非空子串，组成的新串与字符串 $B$ 的前j个字符相等的方案数。
状态计算，从最后一步分析，对于字符串 $A$ 的第i个字符可以选择用或者不用，分为下面2种情况：
- 不使用第i个字符，方案数为：f[i-1][j][k]
- 使用第i个字符，那么第i个字符可以作为第k个子串的结尾，那么该子串的长度可以为 $1, 2, ..., j$ ，又可以分为 $j$ 种情况：
  - 第k个子串长度为 $1$ ，方案数为f[i-1][j-1][k-1]
  - 第k个子串长度为 $2$ ，方案数为f[i-2][j-2][k-1]
  - …
  - 第k个子串长度为 $t$ ，方案数为f[i-t][j-t][k-1]， $t\le j$
  - …
  - 第k个子串长度为 $j$ ，方案数为f[i-j][0][k-1]
  注意：上述情况的方案存在的前提是 $A$ 的子串 $A [i - t + 1... i]$ 和 $B$ 的子串 $B [j - t + 1... j]$ 是相等的，否则对应情况的方案数为 $0$ 。
因此f[i][j][k]的方案总数为：f[i][j][k] = f[i-1][j][k] + (f[i-1][j-1][k-1] + f[i-2][j-2][k-1]+...+f[i-j][0][k-1])
初始状态：f[0][0][0] = 1

时间复杂度

状态数为 $n\times m\times k$ ，其中 $k\le m$ ，因此状态数为 $O(nm^2)$ ；状态计算的次数为 $k$ ，因此时间复杂度为 $O(nm^3)=1000\times200^3=8,000,000,000$ 。

代码实现

#include <iostream>
#include <cstring>
using namespace std;
const int N = 1010, M = 210, MOD = 1e9 + 7;
int f[N][M][M];
char a[N], b[M];

int main()
{
    int n, m, K;
    cin >> n >> m >> K;
    scanf("%s%s", a + 1, b + 1);
    f[0][0][0] = 1;
    for(int i = 1; i <= n; i ++) //枚举字符串a的每个位置	
        for(int j = 0; j <= m; j ++) //枚举字符串b的每个位置	
            for(int k = 0; k <= K; k ++) //枚举k个互不重叠的非空子串
            {
                int sum = 0; //计算使用第i个字符情况下的方案总数
                //枚举第k个子串的长度t
                for(int t = 1; t <= j; t ++)
                {
                    if(a[i - t + 1] != b[j - t + 1]) break; //如果子串不相等，则接下来的方案数都为0
                    sum = (sum + f[i - t][j - t][k - 1]) % MOD; //累加不同情况的方案数
                }
                f[i][j][k] =(f[i - 1][j][k] + sum) % MOD; //计算不使用第i个字符和不是用第i个字符的方案总数
            }
    cout << f[n][m][K]; 
    return 0;
}

时空优化（100分）

首先考虑时间复杂度的优化。

根据上述分析，状态转移方程f[i][j][k] = f[i-1][j][k] + (f[i-1][j-1][k-1] + f[i-2][j-2][k-1] + ... + f[i-j][0][k-1])，不妨设sum[i][j][k] = f[i-1][j-1][k-1] + f[i-2][j-2][k-1] + ... + f[i-j][0][k-1]，那么f[i][j][k] = f[i-1][j][k] + sum[i][j][k]；而sum[i][j][k]根据 $A [i]$ 和 $B [j]$ 是否相同可以分为 $2$ 类：

当 $\ne B[j]$ 时，那么以 $A [i]$ 作为结尾的子串方案数为 $0$ ，即sum[i][j][k] = 0
当 $A [i] = B [j]$ 时，sum[i][j][k] = f[i-1][j-1][k-1] + sum[i-1][j-1][k]，其中sum[i-1][j-1][k] = f[i-2][j-2][k-1] + ... + f[i-j][0][k-1]

因此可以通过递推得到sum[i][j][k]，从而将状态计算的时间复杂度降为 $O (1)$ ，总的时间复杂度变为 $O(nm^2)=1000\times200^2=40,000,000$ 。

其次考虑空间复杂度的优化

仔细分析转移方程f[i][j][k] = f[i-1][j][k] + sum[i][j][k]，发现f[i][j][k]只与i - 1阶段的状态有关。因此可以使用滚动数组进行优化。同时可以发现j和k只会从更小的值转移过来，因此可以使用类似于01背包问题优化空间的方式，从大到小枚举j、k。这样可以直接忽略状态中的第一维，空间复杂度变为 $O(m\times k)=200^2=40,000$ 。

代码实现

滚动数组

#include <iostream>
using namespace std;
const int N = 1010, M = 210, MOD = 1e9 + 7;
int f[2][M][M], sum[2][M][M];
char a[N], b[M];
int main()
{
    int n, m, K;
    cin >> n >> m >> K;
    scanf("%s%s", a + 1, b + 1);
    f[0][0][0] = 1;
    for(int i = 1; i <= n; i ++)
        for(int j = 0; j <= m; j ++)
            for(int k = 0; k <= K; k ++)
            {
                if(a[i] != b[j]) sum[i & 1][j][k] = 0; //以a[i]结尾的子串的方案数为0
                else 
                {
                    if(j > 0) //存在该状态
                    {
                    	//递推求sum[i][j][k]
                        sum[i & 1][j][k] = sum[i & 1][j - 1][k]; 
                        if(k > 0) sum[i & 1][j][k] = (f[i - 1 & 1][j - 1][k - 1] + sum[i - 1 & 1][j - 1][k]) % MOD; 
                    }
                }
                f[i & 1][j][k] = (f[i - 1 & 1][j][k] + sum[i & 1][j][k]) % MOD;
            }
    cout << f[n & 1][m][K];
    return 0;
}

空间优化

#include <iostream>
using namespace std;
const int N = 1010, M = 210, MOD = 1e9 + 7;
int f[M][M], sum[M][M];
char a[N], b[M];
int main()
{
    int n, m, K;
    cin >> n >> m >> K;
    scanf("%s%s", a + 1, b + 1);
    f[0][0] = 1;
    for(int i = 1; i <= n; i ++)
        for(int j = m; j >= 0; j --)
            for(int k = K; k >= 0; k --)
            {
                if(a[i] != b[j]) sum[j][k] = 0; //以a[i]结尾的子串的方案数为0
                else sum[j][k] = (f[j - 1][k - 1] + sum[j - 1][k]) % MOD; 
                f[j][k] = (f[j][k] + sum[j][k]) % MOD; //递推求sum[i][j][k]
            }
    cout << f[m][K];
    return 0;
}