HDU 4641 K string 后缀自动机

原题链接

题意

• 每个测试点，一开始给我们n,m,k然后是一个长度为n的字符串。

• 之后m次操作，1 c是往字符串后面添加一个字符c，2是查询字符串中出现k次以及以上的子串个数，m为2e5

思路

• 首先可以看出这是在线算法（离线其实也可以），然后是查询出现至少k次的子串，这样我们可以直接联系到后缀自动机，与我们本题的需求较为契合

• 我们知道后缀自动机中，每个节点代表的不同子串数量为

\[cnt_v = len(v) - len(link(v))
\]

• 而每个节点的出现次数是其本身与link树的所有子树的标记次数之和，所以每次插入一个字符之后，我们都沿着link向上更新，对沿路节点的标记+1，如果出现了加完后标记正好为k的节点，则

\[ans += len(v) - len(link(v)
\]

然后如果某个节点在访问之前就达到了k，则不需要继续向上更新了，因为上面的节点也肯定大于等于k，并且在之前就被记录了

AC代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 250000;
int n, m, k, last = 0, co = 0;
long long ans = 0;
char ss[N + 5];
struct Sam
{
	int fl;
	int len;
	int fail;
	int sn[26];
} sam[N * 2 + 5];
void inits(int o)
{
	sam[o].fail = -1;
	sam[o].len = 0;
	sam[o].fl = 0;
	for (int i = 0; i < 26; ++i)
	{
		sam[o].sn[i] = 0;
	}
}
void update(int o)
{
	while (o > 0 && sam[o].fl < k)
	{
		++sam[o].fl;
		if (sam[o].fl >= k)
		{
			ans += sam[o].len - sam[sam[o].fail].len;
		}
		o = sam[o].fail;
	}
}
void add(char c)
{
	int noww = ++co;
	inits(noww);
	sam[noww].len = sam[last].len + 1;
	int p = last;
	while (p != -1 && !sam[p].sn[c - 'a'])
	{
		sam[p].sn[c - 'a'] = noww;
		p = sam[p].fail;
	}
	if (p == -1)
	{
		sam[noww].fail = 0;
	}
	else
	{
		int q = sam[p].sn[c - 'a'];
		if (sam[q].len == sam[p].len + 1)
		{
			sam[noww].fail = q;
		}
		else
		{
			int cp = ++co;
			sam[cp] = sam[q];
			sam[cp].len = sam[p].len + 1;
//			sam[cp].fl = 0;
			sam[q].fail = cp;
			sam[noww].fail = cp;
			while (p != -1 && sam[p].sn[c - 'a'] == q)
			{
				sam[p].sn[c - 'a'] = cp;
				p = sam[p].fail;
			}
		}
	}
	last = noww;
	update(noww);
}
int main()
{
	while (scanf("%d%d%d", &n, &m, &k) == 3)
	{
		co = 0;
		last = 0;
		scanf("%s", ss);
		ans = 0;
		inits(0);
		for (int i = 0; ss[i]; ++i)
		{
			add(ss[i]);
		}
		for (int i = 1; i <= m; ++i)
		{
			int opt;
			scanf("%d", &opt);
			if (opt == 1)
			{
				char c[5];
				scanf("%s", c);
				add(c[0]);
			}
			else
			{
				printf("%lld\n", ans);
			}
		}
	}
	return 0;
}