【NOIP2015】子串

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

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

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

输入格式

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

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

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

输出格式

输出共一行，包含一个整数，表示所求方案数。

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

样例一

input

6 3 1
aabaab
aab

output

2

样例二

input

6 3 2
aabaab
aab

output

7

样例三

input

6 3 3
aabaab
aab

output

7

explanation

所有合法方案如下：（加下划线的部分表示取出的子串）

样例一：aab aab / aab aab

样例二：a ab aab / a aba ab / a a ba ab / aab a ab / aa b aab / aa baa b / aab aa b

样例三：a a b aab / a a baa b / a ab a a b / a aba a b / a a b a a b / a a ba a b / aab a a b

限制与约定    1<=n<=1000 1<=m<=200

分析： 

方法一（正解）：
状态：f[k][i][j]: 在A的前i个中切出k段，构成b[1]b[2]...b[j],并保证第k段的结尾一定为a[i]的方案数; 

决策：     (1)a[i]!=b[j]   f[k][i][j]=0;

(2)a[i]==b[i]  a[i]单独成段；

(3)a[i]==b[i]&&a[i-1]==b[i-1]   a[i]与a[i-1]在一段中；
方程： f[k][i][j] = cigema {f[k-1][p][j-1]} ;      ——（2）
( A[i]==B[j]&&A[i-1]!=B[j-1])   
  cigema {f[k-1][p][j-1]}+f[k][i-1][j-1];   ——（3）
  ( A[i]==B[j]&&A[i-1]==B[j-1])
记下 sum[k][i][j]=cigema {f[k-1][p][j-1]} ;(前缀和)
sum[k][i][j]=sum[k][i-1][j]+f[k][i][j];
  时间复杂度O(nmk) ,空间复杂度过高
 f[i][j][k]只与f[k-1][j][k]有关，可以对于第一维用滚动数组。 

注意由于状态定义，最后要输出的是cigema{f[k][i][m]}  (k<=i<=n);

代码如下：

#include  
#include  
#include  
using namespace std;  
const int maxn=1000+5,maxm=200+5,mod=1000000007 ;
bool mark[maxn][maxm];
char a[maxn],b[maxm];
int n,m,maxk,f[3][maxn][maxm],sum[3][maxn][maxm];
int main(){
	int i,j,k;
	scanf("%d%d%d",&n,&m,&maxk);
	scanf("%s%s",a+1,b+1);
	for(i=0;i<=n;i++)
			sum[0][i][0]=1;
	for(k=1;k<=maxk;k++){
		memset(sum[k&1],0,sizeof(sum[k&1]));
		memset(f[k&1],0,sizeof(f[k&1]));
		for(i=k;i<=n;i++)
			for(j=k;j<=m&&j<=i;j++){
				if(a[i]==b[j])
					f[k&1][i][j]=sum[!(k&1)][i-1][j-1];
				if(a[i]==b[j]&&a[i-1]==b[j-1])
					f[k&1][i][j]=(f[k&1][i][j]+f[k&1][i-1][j-1])%mod;
				//cout<<"f ("<

但实际做题的时候，并没有想到正解的方法，先想到了一个勉强能过的方法：

方法二：

状态：f[k][i][j]: 在A的前i个中切出k段，构成b[1]b[2]...b[j]的方案数。

     决策：a[i]和哪些组成一段。

     方程： 第k段的长度为p 

f[k][i][j]= f[k][i-1][j]   (不用a[i])  + cigema{f[k-1][i-p-1][j-p-1]}  

其中,p<=min(i,j) && min(i-p-1,j-p-1)>=k-1   （保证下标为正）

a[i-p].....a[i]==b[j-p].....b[j]   （能够组成一段）  注意这个条件其实很难满足

这个方法的缺点是无法进行时间上的优化，优点是状态更简单，最后输出f[k][n][m]即可

时间复杂度O(n^4)，理论上过不了，但是实际运行中，p的循环次数很少，所以勉强能过。

空间上仍然要使用滚动数组进行优化。

代码如下：

#include    
#include    
#include 
 
using namespace std; 
const int maxn=1000+5,maxm=200+5,mod=1000000007;
int f[3][maxn][maxm],n,m,maxk;
char a[maxn],b[maxn];
int main(){
	int i,j,k,p;
	scanf("%d%d%d",&n,&m,&maxk);
	scanf("%s%s",a+1,b+1);
	for(i=0;i<=n;i++)f[0][i][0]=1;  //注意初值 
	for(k=1;k<=maxk;k++)
		for(i=k;i<=n;i++)
			for(j=k;j<=i&&j<=m;j++){
				f[k&1][i][j]=f[k&1][i-1][j]%mod;
				for(p=0;p<=min(i,j)&&min(i-p-1,j-p-1)>=k-1;p++){
					if(a[i-p]!=b[j-p])break;  //已经无法构成一段了 
					f[k&1][i][j]=(f[k&1][i][j]+f[!(k&1)][i-p-1][j-p-1])%mod;
					//cout<<"f ("<