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

题目链接

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

题目描述

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

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

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

输入格式

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

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

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

输出格式

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

由于答案可能很大，所以这里要求输出答案对 1000000007 1000000007 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 ≤ n ≤ 500 , 1 ≤ m ≤ 50 , k = 1 1≤n≤500,1≤m≤50,k=1 1≤n≤500,1≤m≤50,k=1;

对于第 2 组至第 3 组数据: 1 ≤ n ≤ 500 , 1 ≤ m ≤ 50 , k = 2 1≤n≤500,1≤m≤50,k=2 1≤n≤500,1≤m≤50,k=2;

对于第 4 组至第 5 组数据: 1 ≤ n ≤ 500 , 1 ≤ m ≤ 50 , k = m 1≤n≤500,1≤m≤50,k=m 1≤n≤500,1≤m≤50,k=m;

对于第 1 组至第 7 组数据: 1 ≤ n ≤ 500 , 1 ≤ m ≤ 50 , 1 ≤ k ≤ m 1≤n≤500,1≤m≤50,1≤k≤m 1≤n≤500,1≤m≤50,1≤k≤m;

对于第 1 组至第 9 组数据: 1 ≤ n ≤ 1000 , 1 ≤ m ≤ 100 , 1 ≤ k ≤ m 1≤n≤1000,1≤m≤100,1≤k≤m 1≤n≤1000,1≤m≤100,1≤k≤m;

对于所有 10 组数据: 1 ≤ n ≤ 1000 , 1 ≤ m ≤ 200 , 1 ≤ k ≤ m 1≤n≤1000,1≤m≤200,1≤k≤m 1≤n≤1000,1≤m≤200,1≤k≤m。

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

• 状态表示：f[i][j][k]表示从字符串 A A A 的前i个字符中取出 k 个互不重叠的非空子串，组成的新串与字符串 B B B的前j个字符相等的方案数。

• 状态计算，从最后一步分析，对于字符串 A A A 的第i个字符可以选择用或者不用，分为下面2种情况：

  • 不使用第i个字符，方案数为：f[i-1][j][k]

  • 使用第i个字符，那么第i个字符可以作为第k个子串的结尾，那么该子串的长度可以为 1 , 2 , . . . , j 1,2,...,j 1,2,...,j，又可以分为 j j j种情况：

    • 第k个子串长度为 1 1 1，方案数为f[i-1][j-1][k-1]
    • 第k个子串长度为 2 2 2，方案数为f[i-2][j-2][k-1]
    • ...
    • 第k个子串长度为 t t t，方案数为f[i-t][j-t][k-1]， t ≤ j t\le j t≤j
    • ...
    • 第k个子串长度为 j j j，方案数为f[i-j][0][k-1]

    注意：上述情况的方案存在的前提是 A A A的子串 A [ i − t + 1... i ] A[i -t+1...i] A[i−t+1...i]和 B B B的子串 B [ j − t + 1... j ] B[j-t+1...j] B[j−t+1...j]是相等的，否则对应情况的方案数为 0 0 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 × m × k n\times m\times k n×m×k，其中 k ≤ m k\le m k≤m，因此状态数为 O ( n m 2 ) O(nm^2) O(nm2)；状态计算的次数为 k k k，因此时间复杂度为 O ( n m 3 ) = 1000 × 20 0 3 = 8 , 000 , 000 , 000 O(nm^3)=1000\times200^3=8,000,000,000 O(nm3)=1000×2003=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 ] A[i] A[i]和 B [ j ] B[j] B[j]是否相同可以分为 2 2 2类：

• 当 A [ i ] ≠ B [ j ] A[i] \ne B[j] A[i]=B[j]时，那么以 A [ i ] A[i] A[i]作为结尾的子串方案数为 0 0 0，即sum[i][j][k] = 0
• 当 A [ i ] = B [ j ] A[i] = B[j] 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(1) O(1)，总的时间复杂度变为 O ( n m 2 ) = 1000 × 20 0 2 = 40 , 000 , 000 O(nm^2)=1000\times200^2=40,000,000 O(nm2)=1000×2002=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 × k ) = 20 0 2 = 40 , 000 O(m\times k)=200^2=40,000 O(m×k)=2002=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;
}