noip2015 子串

题目描述

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

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

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

输入输出格式

输入格式：

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

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

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

输出格式：

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

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

隔壁的同学想用kmp，后来大概10分。。。。

这道题正解字符串DP，和最长公共子序列类似。

我们记录dp[i][j][k]表示主串匹配到i位，匹配串匹配到j位，分成了k段的种类。

于是对于a[i]==b[j]我们可以知道，新的这位既可以单独算新的一段，也可以合并在刚才的一段。

但是，如果合并在上一段，我们必须要保证上一位是取的，所以我们记录dp[i][j][k][1]表示上位取的情况，0表示无所谓取没取。

可以得到转移方程：dp[i][j][k][1]=dp[i-1][j-1][k][1](直接加在后面)+dp[i-1][j-1][k-1][0](单独成为一段)

那么0怎么求？那么就是这一位取的加上这一段没取的（也就是上一段的0）

dp[i][j][k][0]=dp[i][j][k][1]+dp[i-1][[j-1][k][0]

然后，如果a[i]!=b[j]，那么这种取法全部为0.

但是，我们发现，这样需要的数组大小是dp[1010][210][210][2]原地爆炸！我们需要压缩。

认真学过普及组算法0/1背包的同学都知道，我们可以用1维数组跑背包，其中dp[j]记录dp[i-1][j]的值，j从大到小枚举，这样每次取的dp[j-1]和dp[j]其实就是dp[i-1][j-1]、dp[i-1][j]

那么转移方程就变为：

dp[j][l][1]=dp[j-1][l][1]+dp[j-1][l-1][0];
dp[j][l][0]=dp[j][l][1]+dp[j][l][0];

代码的注释是压缩之前的方程：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <cstring> 
#define REP(i,k,n)  for(int i=k;i<=n;i++)
#define in(a) a=read();
#define MAXN 2010
#define mod 1000000007
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    for(;!isdigit(ch);ch=getchar())
        if(ch=='-')
            f=-1;
    for(;isdigit(ch);ch=getchar())
        x=x*10+ch-'0';
    return f*x;
}
int n,m,k;
char t[MAXN],s[MAXN];
//int dp[1010][50][50][2];
int f[220][220][2];
int main(){
    in(n);in(m);in(k);
    scanf("%s",s+1);
    scanf("%s",t+1);
    f[0][0][0]=1;
    REP(i,1,n)
        for(int j=m;j>=1;j--){//REP(j,1,m){
            if(s[i]==t[j])
                for(int l=min(k,j);l>=1;l--){//REP(l,1,k){
                    //dp[i][j][l][1]=dp[i-1][j-1][l][1]+dp[i-1][j-1][l-1][0];
                    //dp[i][j][l][0]=dp[i][j][l][1]+dp[i-1][j][l][0];
                    f[j][l][1]=(f[j-1][l][1]+f[j-1][l-1][0])%mod;
                    f[j][l][0]=(f[j][l][1]+f[j][l][0])%mod;
                }
            else
                REP(l,1,k)  f[j][l][1]=0;
                    //dp[i][j][l][1]=0;
            }
    cout<<f[m][k][0];
}