子串和子序列(DP)

　　

原题：

子串和子序列

时间限制: 1 Sec  内存限制: 512 MB

题目描述

输入两个字符串s和t，他们都仅由小写字母构成。令x是s的非空子串，y是t的非空子序列，问有多少种方式构造x和y，使得x与y相等（构造子串和子序列时，只要位置不一样，就算不同的构造方式），答案对1000000007(10^9+7)取模。

输入

第一行输入s，第二行输入t。

输出

输出对1000000007(10^9+7)取模后的答案。

样例输入

aa

aa

样例输出

5

提示

方案有：s[1]=t[1],  s[2]=t[1],  s[1]=t[2],  s[2]=t[2],  s[1]s[2]=t[1][t2] 共5种
样例输入2：
codeforces
forceofcode
样例输出2：
60
【数据规模和约定】
30%数据  1<=s,t字符串长度<=15
另有20%数据  字符串全部由同一个字母构成
100%数据 1<=s,t字符串长度<=5000

 

 

---

 

题意：

　　找出字符串s的子串与t的子序列相同的所有情况数量（位置不同算不同的方案）。

　　我看到这道题，首先对子串和子序列的定义想了好久（我太菜了555）

 

　　度娘说：子串——串中任意个连续的字符组成的子序列称为该串的子串。

　　　　　　子序列——某个序列的子序列是从最初序列通过去除某些元素但不破坏余下元素的相对位置（在前或在后）而形成的新序列。

 

　　简单来说，子串就是在原字符串中截取一段连续的字符组成新的字符串，原题要求非空。子序列就是在原字符串中按顺序抽取几个字符组成新的字符串。

　　例如字符串dfgsthfhgfher，gsthfhg是它的子串，dfhgher是它的子序列。

　　看懂题目并企图打满分的我首先想到的就是dfs，枚举s中每一种情况，用dfs在t中搜索这个子串并统计数量。

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
using namespace std;
const int M=1e9+7;
string rec,str1,str2;
int len1,len2;
long long res,C[5005][5005];;
void dfs(int le,int ri,int pos)
//传入的三个元素分别代表正在搜索的字符的下标、子串最后的字符的下标、目前已搜索到pos位置 
{
    if(le>ri)  { res=(res+1)%M; return; }
    //如果目前正在搜索的字符是末尾下一个字符，代表子串前面字符都被搜索到，这个子串也是t的子序列，记录结果并返回 
    for(int i=pos;i<len2;i++)//从当前位置搜索到t的结尾
        if(str2[i]==str1[le])  dfs(le+1,ri,i+1);
    //若如果找到了正在查找的字符，就在剩下的s中查找下一个字符，或者舍弃这个字符不要继续查找当前字符 
return;
}
int main()
{
    cin>>str1>>str2;
    len1=str1.length(),len2=str2.length();
    for(int i=0;i<len1;i++)
        for(int j=i;j<len1;j++)  dfs(i,j,0);
        //枚举s的子串起点与终点(i,j)
    printf("%lld",res);
return 0;
}

　　然后毫不意外的TLE了，只过了30分的基础分。

　　于是想不到正解的我开始骗20分的数据。

　　s和t都是由相同的字符组成，假设s长度为len1，t长度为len2，那么对于s而言，由一个字符组成的子串有len1个，对于t而言这样的子序列有len2个，总个数就是len1*len2；

　　同样的，由两个相同字符组成的子串有len-1个，对于t而言这样的子序列相当于在len2个字符中取2个，用组合，数量为C[len2][2]，乘法原理可得总个数就是（len1-1）*C[len2][2]。

　　同理，由三个字符组成的子串与子序列的总情况个数为（len1-2）*C[len2][3]。

　　于是就有了我的50分代码（懒得注释）

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
using namespace std;
const int M=1e9+7;
string rec,str1,str2;
int len1,len2;
long long res,C[5005][5005];;
void dfs(int le,int ri,int x)
{
    if(le>ri)  { res=(res+1)%M; return; }
    for(int i=x;i<len2;i++)
        if(str2[i]==str1[le])  dfs(le+1,ri,i+1);
return;
}
void sovle()
{
    for(int i=1;i<=len2;i++)
    {
        C[i][0]=C[i][i]=1;
        for(int j=1;j<i;j++)
            C[i][j]=(C[i-1][j]+C[i-1][j-1])%M;
    }
    for(int i=1;i<=min(len1,len2);i++)
        res=(res+(len1-i+1)*C[len2][i])%M;
}
int main()
{
    cin>>str1>>str2;
    len1=str1.length(),len2=str2.length();
    if(len1<=15 && len2<=15)
    {
        for(int i=0;i<len1;i++)
            for(int j=i;j<len1;j++)  dfs(i,j,0);
    }
    else  sovle();
    printf("%lld",res);
return 0;
}

　　后来看到了正解是DP，f[i][j]表示s第i个字符为结尾的子串与t前j个字符中的子序列相同的数量。

　　如果s与t相同位置的字符相同（即s[i]=t[j]），f[i][j-1]的方案都是f[i][j]的方案，s[i]和t[j]分别为s子串与t子序列单独为一个方案，在f[i-1][j-1]的所有方案中，末尾都添加字符s[i]构成新的方案，数量为f[i-1][j-1]

　　所以状态转移方程是f[i][j]=f[i][j-1]+f[i-1][j-1]+1或f[i][j]=f[i][j-1]（tql）。

#include<iostream.h>
#include<stdio.h>
using namespace std;
const int M=1e9+7;
int n,m,f[5005][5005],ans;
char s[5005],t[5005];
int main()
{
    scanf("%s%s",s+1,t+1);
    n=strlen(s+1),m=strlen(t+1);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(s[i]==t[j])
                f[i][j]=(f[i][j-1]+f[i-1][j-1]+1)%M;
            else  f[i][j]=f[i][j-1];
    for(int i=1;i<=n;i++)  ans=(ans+f[i][m])%M;
    printf("%d",ans);
return 0;
}