【NOIP2015】子串

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

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

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

输入格式

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

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

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

输出格式

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

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

样例一

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<iostream>  
#include<cstdio>  
#include<cstring>  
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 ("<<k<<","<<i<<","<<j<<") == "<<f[k][i][j]<<endl; 
				sum[k&1][i][j]=(sum[k&1][i-1][j]+f[k&1][i][j])%mod;
			}
		}
	int ans=0;
	for(i=maxk;i<=n;i++)ans=(ans+f[maxk&1][i][m])%mod;
	printf("%d\n",ans%mod);
	return 0;
} 

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

方法二：

状态：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<iostream>    
#include<cstdio>    
#include<cstring> 
 
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 ("<<k<<","<<i<<","<<j<<") == "<<f[k&1][i][j]<<endl;  
				}
			}
	printf("%d\n",f[maxk&1][n][m]%mod);
	return 0;
}