P1026 统计单词个数

原题链接

外网进不去
P1026 统计单词个数

题目大意

有一个字符串，以每行20个的方法输入（每行都满20个），一共有 $p(p\le 10)$ 行。题目又会给出 $n$ 个单词，求将这个字符串分成 $1<k\le 40$ 个部分后字符串最多能包含多少个单词（单词可以重叠，但是重叠的单词的前缀不可以一样）。

解题思路

因为从字符串中截取一段中所包含的单词数是一定的，所以只要保证前面的单词数最多，就可以保证答案最多。这样，这个问题就变为了要解决它的子问题。于是，我们可以使用动态规划来解决。如果这么来思考，使用 $f_{i,j}$ 表示前 $i$ 个字符分成 $j$ 部分最多可以有多少个单词，那么不难得到（设$work(n,m)$表示$n\sim m$中的单词个数）：
f i , j = m a x i ≤ 20 × p , j ≤ k , j ≤ l ≤ i { f i − 1 , l − 1 + w o r k ( l , i ) } f_{i,j}=max_{i\le 20\times p,j\le k,j\le l\le i}\{f_{i-1,l-1}+work(l,i)\} fi,j​=maxi≤20×p,j≤k,j≤l≤i​{fi−1,l−1​+work(l,i)}

代码实现

#include<iostream>
#include<cmath>
#include<cstring>
using namespace std;
int n,m,p,k,f[1010][100];
string s1[10],s2,t;
int work(string s)
{
	int value=0;
	for(int i=0;i<s.size();i++){//枚举开始位置
		for(int j=1;j<=n;j++){//枚举单词
			if(i+s1[j].size()-1<s.size()){//判断出界
				if(s.substr(i,s1[j].size())==s1[j]){//是否为一个单词
					value++;
					break;//保证单词的前缀不一样
				}
			}
		}
	}
	return value;
}
int main()
{
	cin>>p>>k;
	for(int i=1;i<=p;i++){
		cin>>t;
		s2+=t;
	}
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>s1[i];
	for(int i=1;i<=s2.size();i++){
		f[i][1]=work(s2.substr(0,i));//初始化，只有一组
	}
	for(int i=1;i<=s2.size();i++){
		for(int j=2;j<=min(k,i-1);j++){//如果i不够分成k分，就只能到i
			for(int l=2;l<=i;l++){
				f[i][j]=max(f[i][j],f[l-1][j-1]+work(s2.substr(l-1,i-l+1)));//转移方程
			}
		}
	}
	cout<<f[20*p][k];//一行20个，一共p行，于是便有20*p个字符
}

但是，当你使用这个代码提交之后：

于是，我们需要考虑优化。
其实，代码中最耗时间的地方就是 $work(n,m)$ 函数，但是如何优化呢？因为调用次数太多，我们考虑记忆化，先预处理所有情况的 $work$ ，并且使用数组记录下来。

#include<iostream>
#include<cmath>
#include<cstring>
using namespace std;
int n,m,p,k,f[1010][100],work_sum[500][500];
string s1[10],s2,t;
int work(string s)
{
	int value=0;
	for(int i=0;i<s.size();i++){//枚举开始位置
		for(int j=1;j<=n;j++){//枚举单词
			if(i+s1[j].size()-1<s.size()){//判断出界
				if(s.substr(i,s1[j].size())==s1[j]){//是否为一个单词
					value++;
					break;//保证单词的前缀不一样
				}
			}
		}
	}
	return value;
}
int main()
{
	cin>>p>>k;
	for(int i=1;i<=p;i++){
		cin>>t;
		s2+=t;
	}
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>s1[i];
	for(int i=0;i<s2.size();i++){//枚举开始位置
		for(int j=1;j<=s2.size()-i+2;j++){//枚举长度
			work_sum[i][i+j-1]=work(s2.substr(i,j));//记忆化初始化
		} 
	}
	for(int i=1;i<=s2.size();i++){
		f[i][1]=work_sum[0][i-1];//初始化，只分一组
	}
	for(int i=1;i<=s2.size();i++){
		for(int j=2;j<=min(k,i-1);j++){//如果i不够分成k分，就只能到i
			for(int l=j;l<=i;l++){
				f[i][j]=max(f[i][j],f[l-1][j-1]+work_sum[l-1][i-1]);//转移方程
			}
		}
	}
	cout<<f[20*p][k];//一行20个，一共p行，于是便有20*p个字符
}

可是，再往学校的网站上一交……（事实证明，洛谷评测机真的好）

要记忆化的想法应该没错，所以想要优化，把 $work$ 换一个方法。这里的 $work$ 是将所有的可能统计出来，不过，其实，我们可以使用前缀和进行优化。
原先的 $work$ 函数，在字符串的每一个位置都找一次，但是，实际上，可以进行一个前缀和优化：
$$su{m}_{i,j}=\{\begin{array}{c}有以第i个字母开头的单词su{m}_{i+1,j}+1\\ 没有有以第i个字母开头的单词su{m}_{i+1,j}\end{array}$$
再三调试之后，终于：

代码实现

#include<iostream>
#include<cmath>
#include<cstring>
using namespace std;
int n,m,p,k,f[1010][100],sum[500][500];
string s1[10],s2,t;
void work()//前缀和初始化
{
	for(int i=s2.size()-1;i>=0;i--){//枚举开始
		for(int j=i;j<s2.size();j++){//枚举结束
			sum[i][j]=sum[i+1][j];//前缀和
			for(int k=1;k<=n;k++){
				if(s2.substr(i,j-i+1).find(s1[k],0)==0){
					sum[i][j]++;
					break;//保证没有单词的前缀相同
				}
			}
		} 
	}
	return;
}
int main()
{
	cin>>p>>k;
	for(int i=1;i<=p;i++){
		cin>>t;
		s2+=t;
	}
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>s1[i];
	work();
	for(int i=1;i<=s2.size();i++){
		f[i][1]=sum[0][i-1];//初始化，只分成一组
	}
	for(int i=1;i<=s2.size();i++){
		for(int j=2;j<=min(k,i-1);j++){//如果i不够分成k分，就只能到i
			for(int l=j;l<=i;l++){//从j开始，是因为前面分成j-1部分，到i结束则是因为方程式只推导到i
				f[i][j]=max(f[i][j],f[l-1][j-1]+sum[l-1][i-1]);//转移方程
			}
		}
	}
	cout<<f[20*p][k];//一行20个，一共p行，于是便有20*p个字符
}

样例1

输入

1 3
thisisabookyouareaoh
4
is
a
ok
sab

输出

7

样例说明

分成 this/isabookyoua/reaoh
this/is|abookyoua/reaoh
this/isabookyoua/reaoh

样例2

输入

1 4
aaaaaaaaaaaaaaaaaaaa
1
aaaa

输出

14

样例说明

分成 aaaaaaaaaaaaaaaaa/a/a/a

样例3

输入

10 30
aaaaaaababaaaaaaaaab
aaaaaaababaaaaaaaaab
aaaaaaababaaaaaaaaab
aaaaaaababaaaaaaaaab
aaaaaaababaaaaaaaaab
aaaaaaababaaaaaaaaab
aaaaaaababaaaaaaaaab
aaaaaaababaaaaaaaaab
aaaaaaababaaaaaaaaab
aaaaaaababaaaaaaaaab
5
ababa
aaa
aaaa
aba
baaa

输出

151