[BJWC2018] Border 的四种求法

【题意】
给你一个字符串 $s$， 每次询问给你两个整数 $l,r$，让你求出 $s_{l,r}$ 的 border。

【思路】
整整想了三天，一开始想用数据结构但是想了很久也不知道怎么维护，然后从border的性质入手想出了一个 $O((n+q)\sqrt{n})$ 的方法。

基于一般根号分治的思想，如果 $border$ 的大小 $<\sqrt{n}$，那么就直接暴力求解。

如果 border的大小 $>\sqrt{n}$，那么其出现的次数不会很多。

我们设块的大小为 $B=10^3$。

对于第二种情况，我们只用考虑$s_{l,l+B-1}$出现的每个位置，然后判断每个位置能不能成为 border。

但这样会遇到一个问题，如果 $s_{l,l+B-1}=aaaaa...aa$ 类似的字符串，那么出现的位置就会是 $O(n)$ 级别的。

我们考虑 $s_{l,l+B-1}$ 的 border。

如果 $border<=\frac{B}{2}$，那么其每次出现的间隔至少为 $\frac{B}{2}$，因此只需要预处理出每个 $s_{i,i+B-1}$ 下一个出现的位置然后暴力求解即可。

如果 $border>\frac{B}{2}$，那么循环节的长度为 $period=B-border$，出现的间隔至少为 $period$，这样就不能暴力求解了。那么我们在逐个位置求解的时候查找这个长度为 $period$ 的循环节能够延申到的最长长度。如果能够延申到 $r$，那么我们只需要判断往下跳多少次 $period$ 能够和前缀匹配上。如果不能延申到 $r$，那么我们还需要考虑 $l$ 处长度为 $period$ 循环节能够延申到的长度， 然后找到当前与之对应的位置判断是否合法（这里比较抽象，稍微思考即可理解），然后把这些位置全部跳过即可。可以证明这样至少跳了$B$ 。

【代码】
因为数据过水，有错误地方请指正，

#include <bits/stdc++.h>
using namespace std;

const int N = 2e5 + 10, B = 1000, mod = 998244353;

int n, m; char s[N];
int val[N], hsh[N];
int nxt[N];
int period[N];
int to[N], to2[N], jump[N];

int gethsh(int l, int r) {
    return (hsh[r] - 1ll * hsh[l - 1] * val[r - l + 1] % mod + mod) % mod;
}

int main() {
    // freopen("in.in", "r", stdin);
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> (s + 1);
    n = strlen(s + 1);

    val[0] = 1;
    for (int i = 1; i <= n; i++) {
        val[i] = 1ll * val[i - 1] * 257 % mod;
        hsh[i] = (1ll * hsh[i - 1] * 257 + s[i]) % mod;
    }
    map<int, int> last;
    for (int i = 1; i <= n; i++) {
        to[i] = n + 1;
    }
    for (int i = 1; i <= n - B + 1; i++) {
        nxt[i] = i - 1;
        for (int j = i + 1, k = i - 1; j <= i + B - 1; j++) {
            while (k > i - 1 && s[k + 1] != s[j]) k = nxt[k];
            if (s[k + 1] == s[j]) k++;
            nxt[j] = k;
        }
        if (nxt[i + B - 1] >= i + B / 2) {
            period[i] = i + B - 1 - nxt[i + B - 1];
        }
        int now = gethsh(i, i + B - 1);
        if (last[now]) {
            to[last[now]] = i;
        }
        last[now] = i;
    }
    last.clear();
    for (int i = n; i >= 1; i--) {
        if (to[i] <= n && i + period[i] == to[i]) {
            jump[i] = jump[to[i]];
        }
        else {
            jump[i] = i;
        }
    }
    for (int i = n - B + 1; i >= 1; i--) {
        if (period[i]) {
            if (to[i] <= n && to[i] == i + period[i]) {
                to2[i] = to2[to[i]];
            }
            else {
                for (int j = i, k = i; j <= n; j++) {
                    if (s[j] != s[k]) {
                        break;
                    }
                    to2[i] = j;
                    k++; if (k == i + period[i]) k = i;
                }
            }
        }
    }
    
    cin >> m;
    while (m--) {
        int l, r; cin >> l >> r;
        int len = r - l + 1;
        if (len <= 2 * B) {           
            for (int i = 2, j = 0; i <= len; i++) {
                while (j && s[l + j] != s[l + i - 1]) j = nxt[j];
                if (s[l + j] == s[l + i - 1]) j++;
                nxt[i] = j;
            }
            cout << nxt[len] << endl;
        }
        else {
            int ans = 0;
            for (int i = 1; i <= B; i++) {
                if (gethsh(l, l + i - 1) == gethsh(r - i + 1, r)) {
                    ans = i;
                }
            }
            if (!period[l]) {
                int x = to[l];
                while (x <= r) {
                    int t = r - x + 1;
                    if (gethsh(l, l + t - 1) == gethsh(x, r)) {
                        ans = max(ans, t);
                        break;
                    }
                    x = to[x];
                }
            }
            else {
                if (to2[l] >= r) {
                    ans = max(ans, r - l + 1 - period[l]);
                }
                else {
                    int x = to[l];
                    while (x + B <= r) {
                        if (to2[x] < r) {
                            if (to2[x] - x >= to2[l] - l && (to[x] - x) % period[l] == (to2[l] - l) % period[l]) {
                                x = to2[x] - (to2[l] - l);
                                int t = r - x + 1;
                                if (gethsh(l, l + t - 1) == gethsh(x, r)) {
                                    ans = max(ans, t);
                                    break;
                                }
                            }
                            x = to[jump[x]];
                        }
                        else {
                            int p1 = to2[l] - l + 1;
                            int p2 = r - x + 1;
                            if (p2 > p1) {
                                int t = (p2 - p1 - 1) / period[l] + 1;
                                p2 -= t * period[l];
                            }
                            ans = max(ans, p2);
                            break;
                        }
                    }
                }
            }
            cout << ans << endl;
        }
    }
}