后缀自动机（模版）

参看博客

构建

struct state {
	int len, link;
	map<char, int> next;
};
const int MAXLEN = 100000;
state st[MAXLEN * 2];
int sz, last;

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

void sam_extend(char c) {
	int cur = sz++;
	st[cur].len = st[last].len + 1;
	int p = last;
	while (p != -1 && !st[p].next.count(c)) {
		st[p].next[c] = cur;
		p = st[p].link;
	}
	if (p == -1) {
		st[cur].link = 0;
	}
	else {
		int q = st[p].next[c];
		if (st[p].len + 1 == st[q].len) {
			st[cur].link = q;
		}
		else {
			int clone = sz++;
			st[clone].len = st[p].len + 1;
			st[clone].next = st[q].next;
			st[clone].link = st[q].link;
			while (p != -1 && st[p].next[c] == q) {
				st[p].next[c] = clone;
				p = st[p].link;
			}
			st[q].link = st[cur].link = clone;
		}
	}
	last = cur;
}

判断是否为子串

bool solve(char str[]) {
	int len = strlen(str);
	int p = 0;
	for (int i = 0; i < len; i++) {
		if (!st[p].next[str[i]])return false;
		p = st[p].next[str[i]];
	}
	return true;
}

字符串的不同子串个数
结果是$f[0]-1$

int dfs(int p) {
	f[p] = 1;
	for (auto x : st[p].next) {
		f[p]+=dfs(x.second);
	}
	return f[p];
}

不同子串的总长度
结果为$ans[0]$
$ans[v]=\sum (ans[u]+f[u])$
$u为v的转移态$

int dfs1(int p) {
	for (auto x : st[p].next) {
		ans[p] += dfs1(x.second)+f[x.second];
	}
	return ans[p];
}

第k小子串
在处理完不同子串的个数的基础上寻找第k小子串,每次从一个数量大于等于k的分支搜索即可。

void dfs_k(int p,int k) {
	if (k == 0)return;
	int ans = 0,pre=0;
	for (auto x : st[p].next) {
		ans += f[x.second];
		if (ans >= k) {
			cout << x.first;
			dfs_k(x.second,k-1-pre);
			return;
		}
		pre = ans;
	}
}

最小循环 移位
结果为s[]，当然这个可以用$O(n)$的最小表示算法求出

char s[N];
bool dfs_cycle(int p, int en,int n) {  //当前访问结点，确定到第几位，字符串的长度
	if (en == n)return true;
	for (auto x : st[p].next) {
		s[en] = x.first;
		if (dfs_cycle(x.second, en + 1, n))return true;
	}
	return false;
}

子串出现的次数
对于每个状态，如果不是复制的就是初始化cnt[i]=1;之后对与所有状态按len从大大小排序，之后就可以

bool cmp(int a, int b) { return st[a].len > st[b].len; }
void init_cnt( ) {
	int tot = 0;
	for (int i = 1; i < sz; i++)a[++tot] = i;
	sort(a+1,a+tot+1,cmp);
	for (int i = 1; i<=tot; i++)cnt[st[a[i]].link] += cnt[a[i]];
}

int dfs_num(char s[]) {
	int  len = strlen(s);
	int p = 0;
	for (int i = 0; i < len; i++) {
		p = st[p].next[s[i]];
		if (p == 0)return 0;
	}
	return cnt[p];
}

子串第一次出现的位置
在创建自动机时就处理firstpos[]数组，如果是新建节点，那么firstpos[cur] = st[cur].len-1，如果是复制得到节点，那么firstpos[clone] = firstpos[q]; 每次直接查询即可。

int dfs_pos(char s[]) {//如果不存在返回-1；
	int len = strlen(s);
	int p = 0;
	for (int i = 0; i < len; i++) {
		p = st[p].next[s[i]];
		if (p == 0)return -1;
	}
	return firstpos[p] - len+1;
}

公共子串

string lcs(const string &S, const string &T) {
  sam_init();
  for (int i = 0; i < S.size(); i++) sam_extend(S[i]);

  int v = 0, l = 0, best = 0, bestpos = 0;
  for (int i = 0; i < T.size(); i++) {
    while (v && !st[v].next.count(T[i])) {
      v = st[v].link;
      l = st[v].length;
    }
    if (st[v].next.count(T[i])) {
      v = st[v].next[T[i]];
      l++;
    }
    if (l > best) {
      best = l;
      bestpos = i;
    }
  }
  return t.substr(bestpos - best + 1, best);
}