【后缀自动机】Luogu P3975 [TJOI2015]弦论题解

[TJOI2015]弦论

题目描述

为了提高智商，ZJY 开始学习弦论。这一天，她在《String theory》中看到了这样一道问题：对于一个给定的长度为 $n$ 的字符串，求出它的第 $k$ 小子串是什么。你能帮帮她吗?

输入格式

第一行是一个仅由小写英文字母构成的字符串 $s$。

第二行为两个整数 $t$ 和 $k$，$t$ 为 $0$ 则表示不同位置的相同子串算作一个，$t$ 为 $1$ 则表示不同位置的相同子串算作多个。$k$ 的意义见题目描述。

输出格式

输出数据仅有一行,该行有一个字符串，为第 $k$ 小的子串。若子串数目不足 $k$ 个，则输出 $-1$。

样例 #1

样例输入 #1

aabc
0 3

样例输出 #1

aab

样例 #2

样例输入 #2

aabc
1 3

样例输出 #2

aa

样例 #3

样例输入 #3

aabc
1 11

样例输出 #3

-1

提示

数据范围

对于 $10\%$ 的数据，$n\le 1000$。

对于 $50\%$ 的数据，$t=0$。

对于 $100\%$ 的数据，$1\le n\le 5\times 10^5$，$0\le t\le 1$，$1\le k\le 10^9$。

---

SOLUTION

子串计数可以用后缀自动机。

后缀自动机的大致思路：

每一个节点保存 $\mathrm{e}\mathrm{n}\mathrm{d}\mathrm{p}\mathrm{o}\mathrm{s}$ （结尾出现位置）集合相同的子串（状态），往 SAM 中添加节点时， $\mathrm{l}\mathrm{a}\mathrm{s}\mathrm{t}$ （上次操作的末尾）的每一个后缀状态（ $\mathrm{e}\mathrm{n}\mathrm{d}\mathrm{p}\mathrm{o}\mathrm{s}$ 不同）若没有为添加字符的连边，则向新节点连添加字符的连边（显然 ）。该点需要通过 $\mathrm{l}\mathrm{i}\mathrm{n}\mathrm{k}$ （后缀连接）连向该状态中，最大的一个字符串，它的最大的后缀使得二者的 $\mathrm{e}\mathrm{n}\mathrm{d}\mathrm{p}\mathrm{o}\mathrm{s}$ 不同，如果不存在则为 $0$ ，存在且为它所在的状态的最大字符串，则将 $\mathrm{l}\mathrm{i}\mathrm{n}\mathrm{k}$ 连向那个状态，否则，创造一个新的节点，克隆那个状态除了 $\mathrm{l}\mathrm{e}\mathrm{n}$ （最大串）的信息，再将那个连向状态的且再 $\mathrm{l}\mathrm{a}\mathrm{s}\mathrm{t}$ 的后缀状态中的边重定向到克隆节点。

这样 SAM 就是一个 $DAG$ ，每一条路径就是子串（不重不漏），沿着最后一个加入的字符对应的节点跳 $\mathrm{l}\mathrm{i}\mathrm{n}\mathrm{k}$ , 每一个经过的节点都是终止节点，即到该节点的路径为后缀。

本题中，对于 $t=0$ 的情况（ $\mathrm{r}\mathrm{o}\mathrm{o}\mathrm{t}$ 为初始状态）：

设 $d_u$ 表示从状态 $u$ 出发向后的路径条数，那么 $d_{root}$ 就是本质不同的子串的个数。

那么可以得到 $d_u$ 的转移方程（$\mathrm{E}$ 表示边集）：

$$d_u=1+\sum _{(u,v,c)\in \mathrm{E}}{d}_v$$

之后，我们对整个 $DAG$ 再进行一遍 $DFS$ ，对于每个节点，按边 'a'~'z' 的顺序枚举，就可以使得枚举从小到大，则：

记录枚举到的所有状态 $v$ ，$d_v$ 的和为 $sum$ ；

若按照边 $i$ 枚举到的下一个状态 $v^{\prime }$ ，$sum+v^{\prime }<k$ ，就 $sum+=k$，此时第 $k$ 小一定不从 $v^{\prime }$ 经过。

否则，第 $k$ 小一定从 $v^{\prime }$ 经过，那么我们令 $sum++$ ，即为状态 $v^{\prime }$ 中最小的子串，并进入 $v^{\prime }$ 递归。

等到 $sum=k$ 时，说明已经找到了答案，返回即可。

复杂度 $O(N)$ ，这样就可以做到 $50\mathrm{p}\mathrm{t}\mathrm{s}$ 。

下面考虑如何将 $t=1$ 的情况转化为第一种：

此时要求算上重数，我们可以通过 $\mathrm{e}\mathrm{n}\mathrm{d}\mathrm{p}\mathrm{o}\mathrm{s}$ 集合的大小来反映子串出现次数。

而对于一个节点 $u$ ，考虑 $\mathrm{l}\mathrm{i}\mathrm{n}\mathrm{k}$ 指向它的所有节点 $v_i$，那么状态 $u$ 中的子串均为 $v_i$ 中的子串的后缀，且根据 $\mathrm{l}\mathrm{i}\mathrm{n}\mathrm{k}$ 的定义，SAM建立的过程中必然存在相应的转移，使得 $v_i$ 的 $\mathrm{e}\mathrm{n}\mathrm{d}\mathrm{p}\mathrm{o}\mathrm{s}$ 集合的交必然 “几乎” 与 $u$ 的相等（这段可以掠过 ），即

记 $Siz{e}_u$ 表示 $u$ 的 $\mathrm{e}\mathrm{n}\mathrm{d}\mathrm{p}\mathrm{o}\mathrm{s}$ 的大小，

若 $u$ 不是克隆节点，则 $Siz{e}_u=1+\sum Siz{e}_{v_i}$， 例如 'p' 在 'pop' 中，包含 'p' 的一个子串就是它本身，所以不会有其他状态转移这个信息，因此要加一。

若 $u$ 是克隆节点，则 $Siz{e}_u=\sum Siz{e}_{v_i}$，例如 ab 在 'cabdab' 中，所有 'ab' 出现的位置都可以被其他子串包含（因为克隆节点是从其他子串中剥离出来的），因此不用加一。

因此可以用拓朴排序处理出这个东西。

接着，我们知道从 $root$ 到任意节点的路径为子串，结束位置的 $\mathrm{e}\mathrm{n}\mathrm{d}\mathrm{p}\mathrm{o}\mathrm{s}$ 的大小就是它出现的次数，因此从一个节点 $u$ 往后的路径（或者选择方式）的数量即为里面经过的状态的 $Size$ 的和，这样我们就可以转化为第一种情况，此时：

$$d_u=Siz{e}_u+\sum _{(u,v,c)\in \mathrm{E}}{d}_v$$

不过需要注意的是，在进行最后的 $DFS$ 时，如果 $sum+Siz{e}_{v_i}\ge k$ （ $v_i$ 是未访问的下一个状态），那么我们的答案路径肯定是以 $v_i$ 结尾的（因为算重，所以此时有多种选择），这时候就需要直接返回，否则我们需要跳过当前状态节点进入下一个状态的选择，就得让 $sum+=Siz{e}_{v_i}$ 。

这样算法的时空复杂度为 $O(N)$ ，具体实现看代码。

---

AC CODE

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#define int long long
using namespace std;

const int N = 5e5 + 10;

struct state
{
	int len, link;
	int Next[26];
}st[N << 1];

char s[N];
int n, t, k;
int deg[N << 1], Size[N << 1], d[N << 1];
int sz, last;
bool flag;

void sam_init()
{
	st[0].len = 0; st[0].link = -1;
	sz ++ ; last = 0;
}

void sam_extended(int c)
{
	int cur = sz ++ , p = last; Size[cur] = 1;
	st[cur].len = st[p].len + 1;
	while(p != -1 && st[p].Next[c] == 0)
	{
		st[p].Next[c] = cur;
		p = st[p].link;
	}
	if(p == -1) st[cur].link = 0, deg[0] ++ ;
	else
	{
		int q = st[p].Next[c];
		if(st[q].len == st[p].len + 1) st[cur].link = q, deg[q] ++ ;
		else
		{
			int clone = sz ++ ;
			st[clone].len = st[p].len + 1;
			st[clone].link = st[q].link;
			memcpy(st[clone].Next, st[q].Next, sizeof st[q].Next);
			while(p != -1 && st[p].Next[c] == q)
			{
				st[p].Next[c] = clone;
				p = st[p].link;
			}
			st[q].link = st[cur].link = clone;
			deg[clone] += 2;
		}
	}
	last = cur;
}

void topsort()
{
	queue<int> q;
	for(int i = 0; i <= sz; i ++ )
		if(deg[i] == 0) q.push(i);
	while(!q.empty())
	{
		int x = q.front(); q.pop();
		if(st[x].link != -1)
		{
			Size[st[x].link] += Size[x];
			if((--deg[st[x].link]) == 0) q.push(st[x].link);
		}
	}
}

int dfs(int x, int op)
{
	if(d[x]) return d[x];
	d[x] = (op ? Size[x] : 1);
	for(int i = 0; i < 26; i ++ )
	{
		if(!st[x].Next[i]) continue;
		d[x] += dfs(st[x].Next[i], op);
	}
	return d[x];
}

void solve(int x, int op, int sum)
{
	if(sum == k) return;
	for(int i = 0; i < 26; i ++ )
	{
		if(!st[x].Next[i]) continue;
		if(sum + d[st[x].Next[i]] < k) { sum += d[st[x].Next[i]]; continue; }
		putchar(i + 'a'); flag = 1;
		if(op && sum + Size[st[x].Next[i]] > k) return;
		solve(st[x].Next[i], op, sum + (op ? Size[st[x].Next[i]] : 1));
		return; 
	}
}

signed main()
{
	scanf("%s%lld%lld", s + 1, &t, &k);
	n = strlen(s + 1); sam_init();
	for(int i = 1; i <= n; i ++ ) sam_extended(s[i] - 'a');
	if(t == 1) topsort();
	dfs(0, t); solve(0, t, 0);
	if(!flag) printf("-1");
	putchar('\n');
	return 0;
}

---

END.