String Algorithm Summary - 1

目录

• Suffix Array Summay
  • 单个字符串问题
    • 不可重叠最长重复子串 (poj1743)
    • 可重叠的 $k$次最长重复子串 (poj3261)
    • 本质不同的子串个数 (spoj694,spoj705,2019牛客多校4I)
    • 最长回文子串 (ural11297,UVA11475)
    • 连续重复子串 (poj 2406)
    • 重复次数最多的连续重复子串 (spoj687,poj3693)
  • 两个字符串问题
    • 最长公共子串 (poj2774, ural11517)
    • 长度不小于$k$的公共子串的个数 (poj3415)
  • 多个字符串问题
    • 不少于$k$个字符串中的最长重复子串 (poj3294,poj3450,poj3080)
    • 每个字符串至少出现两次且不重叠的最长子串 (spoj220,poj1226)
• AC-Automaton Summary
  • 求长度为n(2e9)不包含给定字符串的合法串个数
  • 包含至少一个词根长度不超过n(2e9)的字符串个数
• Suffix Automaton Summary
  • SAM 的定义
  • SAM的性质
  • 子串的性质
  • 结束位置 endpos
• Palindromic Tree(回文自动机) Summary
• Kmp & ExKmp Summary
• Manacher Summary
• Hash Summary
• 习题

Suffix Array Summay

参考：罗大佬后缀数组论文

单个字符串问题

不可重叠最长重复子串 (poj1743)

二分答案把题目变成判定性问题。判断是否存在两个长度为\(k\)的子串是相同的。利用\(height\)数组将排序的后缀分成若干组，其中每组后缀的\(height\)都小于\(k\)。记录每组中\(sa[i]\)的最大值和最小值即可。

可重叠的 \(k\)次最长重复子串 (poj3261)

出现次数至少\(k\)次，还是二分答案，常用套路按\(height\)分组，若存在一组后缀个数不小于\(k\)即有解。

本质不同的子串个数 (spoj694,spoj705,2019牛客多校4I)

每个子串定是某个后缀的前缀，问题转化为求所有后缀之间不相同的前缀个数。枚举排序后的后缀数组，新加入一个后缀\(suffix(sa[k])\)后将产生\(n-sa[k]+1-height[k]\)个新的子串，累加即可答案为\(\frac {n*(n+1)}2-\sum height[i]\)。

最长回文子串 (ural11297,UVA11475)

将原串反过来用一个特殊字符拼在一起，枚举每一位，分奇数串和偶数串计算以这个字符为中心的最长回文子串。两种情况都可转化为求一个后缀和反过来写的后缀的\(lcp\)，求出\(height\)数组即可解决此问题。

连续重复子串 (poj 2406)

连续重复串：如果一个字符串\(L\)是由某个字符串\(S\)重复\(R\)次而得到的，则称\(L\)是一个连续重复串。\(R\)是这个字符串的重复次数。

求最小循环节，\(kmp：\frac {len}{len-nex[len]}\)；枚举答案\(k\)，若\(lcp(suf(1),suf(1+k))==n-k\)即可。

重复次数最多的连续重复子串 (spoj687,poj3693)

这题看到网上很多大致思路相同，但是做法是假的的写法，我自己乱改了一下复杂度很稳定了。

先枚举\(len\)，得到重复次数最多的那些\(len\)，然后枚举求解字典序最小。记这个子字符串为\(S\)，那么\(S\)肯定包括了字符\(r[0],r[len],r[len*2],...\)中的某相邻的两个。先看字符\(r[len*i],r[len*(i+1)]\)往后能匹配长度\(L\)，因为答案的字符串可能不是以\(r[L*i]\)开头，但我们知道他错位数一定是\(cha=len-L\%len\)。所以我们把当前枚举的字符向前移\(cha\)位那个字符开始再求一遍\(lcp(suf(x),suf(x+len))\)即可，答案是\(\frac L{len}+1\)。

得到重复次数最多的那些\(len\)后，枚举排序后的后缀，在枚举\(len\)看是否合法即可。

---

两个字符串问题

最长公共子串 (poj2774, ural11517)

按后缀排序后求排名相邻的不在同一串的两个后缀的\(height\)值的最大值。

长度不小于\(k\)的公共子串的个数 (poj3415)

两串用一个不出现字符拼在一起求一遍后缀数组，分别算一次\(s\)串对\(t\)串的贡献和\(t\)串对\(s\)串的贡献。

令\(height[i]=max(height[i]-k+1,0)\)这是合法的贡献数量，维护一个单调递增的栈，栈里每个元素记录两个值：\(height[],num\)（\(num\)是贡献次数）。压入元素进栈后，弹出的元素的\(height\)值肯定把你压入元素的\(height\)要大，你要把弹出元素的\(num\)累加到新元素里面去。压入和弹出时要动态维护贡献值。每个元素贡献都是\(height\)乘上\(num\)。大致代码如下：

for(int i = 2; i <= n + m + 1; ++i) {//分别算一次s对t的贡献和t对s的贡献
    vs.eb(SA.height[i]);
    if(SA.sa[i-1] > n) sum += SA.height[i];is.eb(1); else is.eb(0);
    while(vs.size() > 2 && vs.back() <= vs[vs.size()-2]) {
        LL vsa = vs.back(), isa = is.back();
        vs.pop_back(); is.pop_back();
        sum -= is.back()*(vs.back() - vsa);
        is[is.size()-1] += isa, vs[vs.size()-1] = vsa;
    }
    if(SA.sa[i] < n) ans += sum;
}

---

多个字符串问题

不少于\(k\)个字符串中的最长重复子串 (poj3294,poj3450,poj3080)

给定\(n(100)\)个字符串(1000)，求出现在不小于\(k\)个字符串中的最长子串。here

可以拼串+二分+常用套路分组判定解决，判断每组的后缀是否出现在不小于\(k\)个的原串中。

也可以直接单调栈写，拼串后记录每个字符所属字符串标号。

记录栈里面属于不同编号的后缀的数量。当栈里面\(lcp\)大小为\(0\)时，要移动左端点。当数量一旦达到\(k\)个，就求一下他们的\(lcp\)，取\(max\)。然后移动左端点，直到不同编号的后缀数量小于k。

int ans = 0, cnt = 1, aim = k/2 + 1, l = 1; ++ vis[id[SA.sa[1]]];
for(int i = 2; i <= len; ++i) {
    if(vis[id[SA.sa[i]]] == 0 && id[SA.sa[i]]) ++ cnt; ++ vis[id[SA.sa[i]]];
    if(cnt >= aim) ans = max(ans, SA.RMQ_query(SA.sa[l+1], SA.sa[i]));
    while(l < i && SA.RMQ_query(SA.sa[l+1], SA.sa[i]) == 0) {
        -- vis[id[SA.sa[l]]];
        if(id[SA.sa[l]] && vis[id[SA.sa[l]]] == 0) -- cnt;
        ++ l; if(cnt >= aim) ans = max(ans, SA.RMQ_query(SA.sa[l+1], SA.sa[i]));
    }
    while(cnt >= aim && l < i) {
        -- vis[id[SA.sa[l]]];
        if(id[SA.sa[l]] && vis[id[SA.sa[l]]] == 0) -- cnt;
        ++ l; if(cnt >= aim) ans = max(ans, SA.RMQ_query(SA.sa[l+1], SA.sa[i]));
    }
}

每个字符串至少出现两次且不重叠的最长子串 (spoj220,poj1226)

给定\(n\)个字符串，求在每个字符串中至少出现两次且不重叠的最长子串。

拼串+二分+常用套路分组判定解决。按\(height\)分组后记录来自每个字符串的\(sa[i]\)的最大值和最小值，当差大于二分的\(mid\)时，\(cnt++\)。

AC-Automaton Summary

AC 自动机是 以 TRIE 的结构为基础 ，结合 KMP 的思想 建立的。可进行多模式匹配。

kmp的next 指针求的是最长 Border（即最长的相同前后缀），而 fail 指针指向所有模式串的前缀中匹配当前状态的最长后缀。

求长度为n(2e9)不包含给定字符串的合法串个数

给定10个长度不超过10的字符串，对其建立AC自动机，将包含给定字符串的节点标记为坏节点。将非坏节点拎出来建立一个矩阵，两点权值为相互转换的方法数。跑一遍矩阵快速莫，第一行总和即为答案。

若n不是很大，可以dp求，\(dp[i][j]=\sum dp[i-1][k]*dis[k][j]\)。

包含至少一个词根长度不超过n(2e9)的字符串个数

5个长度不超过5的词根。用总方案数减去不合法方案数，不合法方案数和上题一样建立AC自动机，取出矩阵。上题总串长度给定，本题貌似需要求一个前缀和，只需在原矩阵基础在最右边添加一列值全为1即可。跑完矩阵快速幂后对第一行求和即可所有不合法方案数。总方案数也是一个简单矩阵构造。

Suffix Automaton Summary

参考：OI-wiki

SAM 的定义

字符串\(s\)的 SAM 是一个接受\(s\)的所有后缀的最小 DFA （确定性有限自动机或确定性有限状态自动机）。

• SAM 是一张有向无环图。节点被称作状态，边被称作状态间的转移。
• 图存在一个源点\(t_0\)，称作初始状态，其他各节点均可从\(t_0\)出发到达。
• 每个转移都标有一些字母。从一个节点出发的所有转移均不同。
• 存在一个或多个终止状态。每个终止状态都是字符串\(s\)的一个后缀。\(s\)的每个后缀均可用一条从\(t_0\)到某个终止状态的路径构成。
• 在所有满足上述条件的自动机中，SAM的节点数是最少的。

SAM的性质

子串的性质

SAM 最简单、也最重要的性质是，它包含关于字符串\(s\)的所有子串的信息。任意从初始状态\(t_0\)开始的路径，如果我们将转移路径上的标号写下来，都会形成\(s\)的一个 子串 。反之每个\(s\)的子串对应从\(t_0\)开始的某条路径。

到达某个状态的路径可能不止一条，因此我们说一个状态对应一些字符串的集合，这个集合的每个元素对应这些路径。

结束位置 endpos

考虑字符串\(s\)的任意非空子串\(t\)，我们记\(endpos(t)\)为在字符串\(s\)中\(t\)的所有结束位置（假设对字符串中字符的编号从零开始）。

字符\(s\)的所有非空子串都可以根据它们的\(endpos\)集合被分为若干 等价类 。

显然，SAM 中的每个状态对应一个或多个\(endpos\)相同的子串。换句话说，SAM 中的状态数等于所有子串的等价类的个数，再加上初始状态。SAM 的状态个数等价于\(endpos\)相同的一个或多个子串所组成的集合的个数\(+1\)。

引理1：两个非空子串\(u\)和\(w\)（假设\(|u|\le|w|\)）的\(endpos\)相同，当且仅当字符串\(u\)是\(w\)的后缀。

引理2：考虑两个非空子串\(u\)和\(w\)（假设\(|u|\le|w|\)）。那么要么\(endpos(u)\cap endpos(w)=\emptyset\)，要么\(endpos(w)\subseteq endpos(u)\)，取决于是否为的一个后缀：

Palindromic Tree(回文自动机) Summary

参考：poursoul

回文树可以干啥？

假设我们有一个串\(S\)，\(S\)下标从\(0\)开始，则回文树能做到如下几点：

1.求串\(S\)前缀\(0 - i\)内本质不同回文串的个数（两个串长度不同或者长度相同且至少有一个字符不同便是本质不同）

2.求串\(S\)内每一个本质不同回文串出现的次数

3.求串\(S\)内回文串的个数（其实就是1和2结合起来）

4.求以下标\(i\)结尾的回文串的个数

空间复杂度为\(O(N*CharSize)\)，时间复杂度为\(O(N*log(CharSize))\)。

应用：hdu6599,2019牛多校4I

/*
pos[]数组记录原字符串端点对应回文树上的端点
len[i]表示编号为i的节点表示的回文串的长度（一个节点表示一个回文串）
next[i][c]表示编号为i的节点表示的回文串在两边添加字符c以后变成的回文串的编号（和字典树类似）。
fail[i]表示节点i失配以后跳转不等于自身的节点i表示的回文串的最长后缀回文串（和AC自动机类似）。
cnt[i]表示节点i表示的本质不同的串的个数(建树时求出的不是完全的，最后count()函数跑一遍以后才对)
num[i]表示以节点i表示的最长回文串的最右端点为回文串结尾的回文串个数。
last指向新添加一个字母后所形成的最长回文串表示的节点。
S[i]表示第i次添加的字符（一开始设S[0] = -1（可以是任意一个在串S中不会出现的字符））。
p表示添加的节点个数。（p-2为本质不同回文串的个数）
n表示添加的字符个数。
一开始回文树有两个节点，0表示偶数长度串的根和1表示奇数长度串的根，且len[0] = 0，len[1] = -1，last = 0，S[0] = -1，n = 0，p = 2（添加了节点0、1）。
*/
struct Palindromic_Tree {
    static const int MAXN = 600005 ;
    static const int CHAR_N = 26 ;
    int next[MAXN][CHAR_N];//next指针，next指针和字典树类似，指向的串为当前串两端加上同一个字符构成
    int fail[MAXN];//fail指针，失配后跳转到fail指针指向的节点
    int cnt[MAXN];
    int num[MAXN];
    int len[MAXN];//len[i]表示节点i表示的回文串的长度
    int S[MAXN];//存放添加的字符
    int last;//指向上一个字符所在的节点，方便下一次add
    int n;//字符数组指针
    int p;//节点指针
    int pos[MAXN];
    int newnode(int l) {//新建节点
        for (int i = 0; i < CHAR_N; ++i) next[p][i] = 0;
        cnt[p] = 0;
        num[p] = 0;
        len[p] = l;
        return p++;
    }
    void init() {//初始化
        p = 0;
        newnode(0);
        newnode(-1);
        last = 0;
        n = 0;
        S[n] = -1;//开头放一个字符集中没有的字符，减少特判
        fail[0] = 1;
    }
    int get_fail(int x) {//和KMP一样，失配后找一个尽量最长的
        while (S[n - len[x] - 1] != S[n]) x = fail[x];
        return x;
    }
    void add(int c, int id) {
        c -= 'a';
        S[++n] = c;
        int cur = get_fail(last);//通过上一个回文串找这个回文串的匹配位置
        if (!next[cur][c]) {//如果这个回文串没有出现过，说明出现了一个新的本质不同的回文串
            int now = newnode(len[cur] + 2);//新建节点
            fail[now] = next[get_fail(fail[cur])][c];//和AC自动机一样建立fail指针，以便失配后跳转
            next[cur][c] = now;
            num[now] = num[fail[now]] + 1;
        }
        last = next[cur][c];
        cnt[last] ++;
        pos[last] = id;
    }
    void count() {
        for (int i = p - 1; i >= 0; --i) cnt[fail[i]] += cnt[i];
        //父亲累加儿子的cnt，因为如果fail[v]=u，则u一定是v的子回文串！
        for(int i = 0, tmp; i < p; ++i) {
            tmp = pos[i];
            if(len[i] % 2 == 0 && get_hash(tmp - len[i] + 1, tmp - len[i]/2) == get_hash(tmp - len[i]/2 + 1, tmp)) ANS[len[i]] += cnt[i];
            else if((len[i] & 1) && get_hash(tmp - len[i] + 1, tmp - len[i]/2) == get_hash(tmp - len[i]/2, tmp)) ANS[len[i]] += cnt[i];
        }
    }
} pt;

Kmp & ExKmp Summary

Manacher Summary

Hash Summary

习题

hdu 6704

#include<bits/stdc++.h>

#define fi first
#define se second
#define endl '\n'
#define mk make_pair
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const int maxn = 3e5 + 7;
const int MXE = 2e5 + 7;
char s[maxn];
int bit[22], lg2[maxn];
int n;
struct qwe {
    int l, r, sum;
} qu[MXE * 40];
int wnis, Rk[maxn];

void update(int l, int r, int last, int &cur, int x) {
    qu[++wnis] = qu[last];
    qu[wnis].sum = qu[last].sum + 1;
    cur = wnis;
    if (l == r) return;
    int mid = (l + r) >> 1;
    if (x <= mid)update(l, mid, qu[last].l, qu[cur].l, x);
    else update(mid + 1, r, qu[last].r, qu[cur].r, x);
}

int query(int l, int r, int p, int lst, int cur) {
    if (l == r) return l;
    int mid = (l + r) >> 1;
    int tmp = qu[qu[cur].l].sum - qu[qu[lst].l].sum;
    if (p <= tmp) return query(l, mid, p, qu[lst].l, qu[cur].l);
    else return query(mid + 1, r, p - tmp, qu[lst].r, qu[cur].r);
}

const int MAXN = 300005;
const int MAXS = MAXN * 2;
int rnk[MAXN], height[MAXN], sa[MAXN];
namespace SA {
    int s[MAXS], t[MAXS];
    int p[MAXN], cnt[MAXN], cur[MAXN];
#define pushS(x) sa[cur[s[x]]--] = x
#define pushL(x) sa[cur[s[x]]++] = x
#define inducedSort(v) fill_n(sa, n, -1); fill_n(cnt, m, 0);                  \
    for (int i = 0; i < n; i++) cnt[s[i]]++;                                  \
    for (int i = 1; i < m; i++) cnt[i] += cnt[i-1];                           \
    for (int i = 0; i < m; i++) cur[i] = cnt[i]-1;                            \
    for (int i = n1-1; ~i; i--) pushS(v[i]);                                  \
    for (int i = 1; i < m; i++) cur[i] = cnt[i-1];                            \
    for (int i = 0; i < n; i++) if (sa[i] > 0 &&  t[sa[i]-1]) pushL(sa[i]-1); \
    for (int i = 0; i < m; i++) cur[i] = cnt[i]-1;                            \
    for (int i = n-1;  ~i; i--) if (sa[i] > 0 && !t[sa[i]-1]) pushS(sa[i]-1)
    void sais(int n, int m, int *s, int *t, int *p) {
        int n1 = t[n-1] = 0, ch = rnk[0] = -1, *s1 = s+n;
        for (int i = n-2; ~i; i--) t[i] = s[i] == s[i+1] ? t[i+1] : s[i] > s[i+1];
        for (int i = 1; i < n; i++) rnk[i] = t[i-1] && !t[i] ? (p[n1] = i, n1++) : -1;
        inducedSort(p);
        for (int i = 0, x, y; i < n; i++) if (~(x = rnk[sa[i]])) {
                if (ch < 1 || p[x+1] - p[x] != p[y+1] - p[y]) ch++;
                else for (int j = p[x], k = p[y]; j <= p[x+1]; j++, k++)
                        if ((s[j]<<1|t[j]) != (s[k]<<1|t[k])) {ch++; break;}
                s1[y = x] = ch;
            }
        if (ch+1 < n1) sais(n1, ch+1, s1, t+n, p+n1);
        else for (int i = 0; i < n1; i++) sa[s1[i]] = i;
        for (int i = 0; i < n1; i++) s1[i] = p[sa[i]];
        inducedSort(s1);
    }
    template<typename T>
    int mapCharToInt(int n, const T *str) {
        int m = *max_element(str, str+n);
        fill_n(rnk, m+1, 0);
        for (int i = 0; i < n; i++) rnk[str[i]] = 1;
        for (int i = 0; i < m; i++) rnk[i+1] += rnk[i];
        for (int i = 0; i < n; i++) s[i] = rnk[str[i]] - 1;
        return rnk[m];
    }
    template<typename T>
    void suffixArray(int n, const T *str) {
        int m = mapCharToInt(++n, str);
        sais(n, m, s, t, p);
        for (int i = 0; i < n; i++) rnk[sa[i]] = i;
        for (int i = 0, h = height[0] = 0; i < n-1; i++) {
            int j = sa[rnk[i]-1];
            while (i+h < n && j+h < n && s[i+h] == s[j+h]) h++;
            if ((height[rnk[i]] = h)) h--;
        }
    }
    int dp[maxn][22];
    int RMQ_query(int l, int r) {//看自己需求自由变换
        int k = lg2[r - l + 1];
//    int k = 0; while (1<<(k+1) <= r - l + 1) k++;
        return min(dp[l][k], dp[r - (1 << k) + 1][k]);
    }
    void RMQ_init(int n) {
        for (int i = 0; i < n; ++i) dp[i][0] = height[i];
        for (int j = 1; (1 << j) <= n; ++j) {
            for (int i = 0; i + (1 << j) - 1 < n; ++i) {
                dp[i][j] = std::min(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1]);
            }
        }
    }
};

pii samquery(int l, int r) {
    -- l, -- r;
    int len = r - l + 1, L = 1, R = rnk[l] - 1, mid, ans = rnk[l] - 1, up = -1, down = -1;
    if (height[rnk[l]] >= len) {
//        debug(1)
        while (L <= R) {
            mid = (L + R) >> 1;
            if (SA::RMQ_query(mid + 1, rnk[l]) >= len) ans = mid, R = mid - 1;
            else L = mid + 1;
        }
        down = ans;
    } else down = rnk[l];
    if (height[rnk[l] + 1] >= len) {
        L = rnk[l] + 1, R = n, ans = rnk[l] + 1;
        while (L <= R) {
            mid = (L + R) >> 1;
            if (SA::RMQ_query(rnk[l] + 1, mid) >= len) ans = mid, L = mid + 1;
            else R = mid - 1;
        }
        up = ans;
    } else up = rnk[l];
    return mk(down, up);
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("/home/cwolf9/CLionProjects/ccc/in.txt", "r", stdin);
    //freopen("/home/cwolf9/CLionProjects/ccc/out.txt", "w", stdout);
#endif
    bit[0] = 1;
    for (int i = 1; i < 22; i++) bit[i] = bit[i - 1] << 1;
    for (int i = 2; i < maxn; ++i) lg2[i] = lg2[i >> 1] + 1;
    int tim, Q;
    scanf("%d", &tim);
    while (tim--) {
        scanf("%d%d%s", &n, &Q, s+1);
        SA::suffixArray(n, s+1);
        height[n+1] = 0;
        SA::RMQ_init(n+1);
        wnis = Rk[0] = qu[0].l = qu[0].r = qu[0].sum = 0;
        for (int i = 1; i <= n; ++i) {
//            cerr << sa[i] << " ";
            update(1, n + 2, Rk[i - 1], Rk[i], sa[i] + 1);
        }
//        cerr << endl;
        int l, r, k;
        while (Q--) {
            scanf("%d%d%d", &l, &r, &k);
//            cerr << l << " " << r << endl;
            pii a = samquery(l, r);
            if (k > qu[Rk[a.se]].sum - qu[Rk[a.fi - 1]].sum) printf("-1\n");
            else printf("%d\n", query(1, n + 2, k, Rk[a.fi - 1], Rk[a.se]));
        }
    }
    return 0;
}