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

题目链接

[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

样例输入 #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$。

算法思想（朴素版动态规划，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+\mathrm{1...}i]$和$B$的子串$B[j-t+\mathrm{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(n{m}^2)$；状态计算的次数为$k$，因此时间复杂度为$O(n{m}^3)=1000\times 200^3=8,000,000,000$。

代码实现

#include 
#include 
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$类：

• 当$A[i]\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(n{m}^2)=1000\times 200^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 
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 
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;
}