HDU2243 考研路茫茫——单词情结 AC自动机DP矩阵优化

最新推荐文章于 2023-09-12 22:31:05 发布

上决FX

最新推荐文章于 2023-09-12 22:31:05 发布

阅读量1.6k

点赞数

分类专栏：数据结构 DP 文章标签： AC自动机 DP acm 矩阵二分幂

本文链接：https://blog.csdn.net/w703710691d/article/details/43272083

版权

数据结构同时被 2 个专栏收录

40 篇文章 0 订阅

订阅专栏

13 篇文章 0 订阅

订阅专栏

传送门：点击打开链接

考研路茫茫——单词情结

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3929 Accepted Submission(s): 1147

Problem Description

背单词，始终是复习英语的重要环节。在荒废了3年大学生涯后，Lele也终于要开始背单词了。
一天，Lele在某本单词书上看到了一个根据词根来背单词的方法。比如"ab",放在单词前一般表示"相反，变坏，离去"等。

于是Lele想，如果背了N个词根，那这些词根到底会不会在单词里出现呢。更确切的描述是：长度不超过L，只由小写字母组成的，至少包含一个词根的单词，一共可能有多少个呢？这里就不考虑单词是否有实际意义。

比如一共有2个词根 aa 和 ab ，则可能存在104个长度不超过3的单词，分别为
(2个) aa,ab,
(26个)aaa,aab,aac...aaz,
(26个)aba,abb,abc...abz,
(25个)baa,caa,daa...zaa,
(25个)bab,cab,dab...zab。

这个只是很小的情况。而对于其他复杂点的情况，Lele实在是数不出来了，现在就请你帮帮他。

Input

本题目包含多组数据，请处理到文件结束。
每组数据占两行。
第一行有两个正整数N和L。(0<N<6,0<L<2^31)
第二行有N个词根，每个词根仅由小写字母组成，长度不超过5。两个词根中间用一个空格分隔开。

Output

对于每组数据，请在一行里输出一共可能的单词数目。
由于结果可能非常巨大，你只需要输出单词总数模2^64的值。

Sample Input

Sample Output

Author

linle

题意：给出n个单词。问长度不超过m的串中，至少包含上述的至少一个单词的串的数目，对2^64取MOD

思路：这道题和POJ 2278比较相似，没有做过的请先参考http://blog.csdn.net/w703710691d/article/details/43271693

与POJ 2278最大的不同的，这道题要求得是长度不超过m的串。就要求得长度为1、2、3……m的符合要求串。可以参照POJ 2278的思路，先求出不符合的串，在用总数减去这个值，就得到了答案。下面设矩阵为A.中间会用到求A+A^2+A^3+……A^m【记为X】和26+26^2+26^3……+26^m次方的值。可以参考二分幂的方法。先求出(A+A^2+A^3……A^(m/2)【记为B】和A^(m/2)的值。那么X=(A^(m/2)+E）*B。E为单位阵。算数的也是同样的方法。将运算过程中的变量和矩阵的元素定义为unsigned __int64，就能实现自动对2^64自动取MOD

代码：

#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cstring>
#define SIGMA_SIZE 26
#define maxn 40
#include<queue>
#define uLL unsigned __int64
using namespace std;
int ch[maxn][SIGMA_SIZE];
int val[maxn];
int last[maxn], f[maxn];
int cnt;
inline int idx(char c)
{
	return c - 97;
}
void insert(char s[])
{
	int len = strlen(s);
	int u = 0;
	for (int i = 0; i<len; i++)
	{
		int v = idx(s[i]);
		if (!ch[u][v]) ch[u][v] = ++cnt;
		u = ch[u][v];
	}
	val[u] = 1;
}
struct Matrix
{
	uLL g[maxn][maxn];
	int r, c;
	Matrix operator * (const Matrix &b) const
	{
		Matrix res;
		res.r = r;
		res.c = b.c;
		memset(res.g, 0, sizeof(res.g));
		for (int i = 0; i <= r; i++)
			for (int j = 0; j <= b.c; j++)
				for (int k = 0; k <= c; k++) res.g[i][j] += g[i][k] * b.g[k][j];
		return res;
	}
	Matrix operator + (const Matrix &b) const
	{
		Matrix res;
		res.r = r;
		res.c = c;
		memset(res.g, 0, sizeof(g));
		for (int i = 0; i <= r; i++)
			for (int j = 0; j <= c; j++) res.g[i][j] = g[i][j] + b.g[i][j];
		return res;
	}
};
Matrix ONE(int M)
{
	Matrix res;
	res.r = M;
	res.c = M;
	memset(res.g, 0, sizeof(res.g));
	for (int i = 0; i <= M; i++) res.g[i][i] = 1;
	return res;
}
Matrix ZERO(int M)
{
	Matrix res;
	res.r = M;
	res.c = M;
	memset(res.g, 0, sizeof(res.g));
	return res;
}
pair<Matrix, Matrix> bin(Matrix a, int k)
{
	pair<Matrix, Matrix> tmp, res;
	if (k == 0)
	{
		return make_pair(ZERO(a.r), ONE(a.r));
	}
	else if (k == 1)
		return make_pair(a, a);
	tmp = bin(a, k >> 1);
	res.first = (tmp.second + ONE(a.r))*tmp.first;
	res.second = tmp.second*tmp.second;
	if (k & 1)
	{
		res.second = res.second*a;
		res.first = res.first + res.second;
	}
	return res;
}
bool vis[maxn];
int mp[maxn][maxn];
void bfs()
{
	memset(vis, 0, sizeof(vis));
	vis[0] = 1;
	queue<int>q;
	q.push(0);
	while (!q.empty())
	{
		int u = q.front();
		q.pop();
		for (int i = 0; i<26; i++)
		{
			int p = u;
			while (p&&!ch[p][i]) p = f[p];
			p = ch[p][i];
			if (val[p]) continue;
			if (last[p]) continue;
			mp[u][p]++;
			if (!vis[p]) q.push(p);
			vis[p] = 1;
		}
	}
}
pair<uLL, uLL> bin(uLL a, int k)
{
	if (k == 1) return make_pair(a, a);
	else if (k == 0) return (make_pair(0, 1));
	pair<uLL, uLL>tmp, res;
	tmp = bin(a, k >> 1);
	res.first = (tmp.second + 1)*tmp.first;
	res.second = tmp.second*tmp.second;
	if (k & 1)
	{
		res.second = res.second*a;
		res.first = res.first + res.second;
	}
	return res;
}
void slove(uLL m)
{
	memset(mp, 0, sizeof(mp));
	bfs();
	Matrix tmp;
	tmp.r = cnt;
	tmp.c = cnt;
	for (int i = 0; i <= cnt; i++)
		for (int j = 0; j <= cnt; j++) tmp.g[i][j] = mp[i][j];
	pair<Matrix, Matrix> res;
	res = bin(tmp, m);
	uLL ans = 0;
	for (int i = 0; i <= cnt; i++) ans += res.first.g[0][i];
	ans = bin(26, m).first - ans;
	printf("%I64u\n", ans);
}
void getFail()
{
	queue<int>q;
	f[0] = 0;
	for (int c = 0; c<SIGMA_SIZE; c++)
	{
		int u = ch[0][c];
		if (u)
		{
			f[u] = 0;
			q.push(u);
			last[u] = 0;
		}
	}
	while (!q.empty())
	{
		int r = q.front();
		q.pop();
		for (int c = 0; c<SIGMA_SIZE; c++)
		{
			int u = ch[r][c];
			if (!u)
			{
				//ch[r][c] = ch[f[r]][c];
				continue;
			}
			q.push(u);
			int v = f[r];
			while (v&&!ch[v][c]) v = f[v];
			f[u] = ch[v][c];
			last[u] = val[f[u]] ? f[u] : last[f[u]];
		}
	}
}
int main()
{
	int n, m;
	while (~scanf("%d %d", &n, &m))
	{
		memset(ch, 0, sizeof(ch));
		memset(val, 0, sizeof(val));
		cnt = 0;
		char s[15];
		for (int i = 1; i <= n; i++)
		{
			scanf("%s", s);
			insert(s);
		}
		getFail();
		slove(m);
	}
	return 0;
}

可能会栈溢出，所以我直接交了C++

上决FX

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
HDU2243 考研路茫茫——单词情结 AC自动机DP矩阵优化

传送门：点击打开链接考研路茫茫——单词情结Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 3929 Accepted Submission(s): 1147Problem Description背单词，
复制链接

扫一扫