洛谷P4384 制胡窜

这题TM是计数神题......SAM就是个板子，别脑残写错就完事了。有个技巧是快速定位子串，倍增即可。

考虑反着来，就是两个断点切割所有串，求方案数。

大概分类讨论一下......先特判掉一些情况。然后考虑最左右的两个串是否相交。

相交的情况比较友善，先特殊统计有断点在交集中。之后枚举第一个断点切割了1 ~ i个串。第二个断点就切割i+1 ~ m个串。

然后写出一个∑的式子，拆开之后发现维护right集合平方和和right集合相邻元素的乘积即可。

不相交的麻烦点(极其麻烦...)考虑枚举第一个断点切割了1~i个串，这里的i的限制是L ~ R，可以先求出来。

然后继续化简一个∑式子，最后发现要维护的东西差不多。于是这题做完了。

感想：对拍真好用.jpg

#include <bits/stdc++.h>

typedef long long LL;
const int N = 200010, M = 10000010;

struct Edge {
    int nex, v;
}edge[N]; int tp;

int tr[N][10], fail[N], len[N], rt[N], last = 1, tot = 1;
int ls[M], rs[M], cnt, e[N], ed[N], fa[N][20], pw[N];
LL sum0[M], sum2[M], sumd[M], large[M], small[M];
int n, q;
char str[N];

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

inline void pushup(int o) {
    if(!ls[o] && !rs[o]) return;
    sum0[o] = sum0[ls[o]] + sum0[rs[o]];
    sum2[o] = sum2[ls[o]] + sum2[rs[o]];
    sumd[o] = sumd[ls[o]] + sumd[rs[o]];
    if(ls[o] && rs[o]) sumd[o] += small[rs[o]] * large[ls[o]];
    large[o] = std::max(large[ls[o]], large[rs[o]]);
    small[o] = std::min(small[ls[o]], small[rs[o]]);
    return;
}

int merge(int x, int y) {
    if(!x || !y) return x | y;
    int o = ++cnt;
    large[o] = large[x];
    small[o] = small[x];
    sum0[o] = sum0[x];
    sum2[o] = sum2[x];
    sumd[o] = sumd[x];
    ls[o] = merge(ls[x], ls[y]);
    rs[o] = merge(rs[x] ,rs[y]);
    pushup(o);
    return o;
}

void insert(int p, int l, int r, int &o) {
    if(!o) o = ++cnt;
    if(l == r) {
        large[o] = small[o] = r;
        sum0[o] = 1;
        sum2[o] = 1ll * r * r;
        sumd[o] = 0;
        return;
    }
    int mid = (l + r) >> 1;
    if(p <= mid) insert(p, l, mid, ls[o]);
    else insert(p, mid + 1, r, rs[o]);
    pushup(o);
    return;
}

inline void insert(char c, int id) {
    int f = c - '0', p = last, np = ++tot;
    last = np;
    insert(id, 1, n, rt[np]);
    len[np] = len[p] + 1;
    while(p && !tr[p][f]) {
        tr[p][f] = np;
        p = fail[p];
    }
    if(!p) {
        fail[np] = 1;
    }
    else {
        int Q = tr[p][f];
        if(len[Q] == len[p] + 1) {
            fail[np] = Q;
        }
        else {
            int nQ = ++tot;
            len[nQ] = len[p] + 1;
            fail[nQ] = fail[Q];
            fail[Q] = fail[np] = nQ;
            memcpy(tr[nQ], tr[Q], sizeof(tr[Q]));
            while(tr[p][f] == Q) {
                tr[p][f] = nQ;
                p = fail[p];
            }
        }
    }
    return;
}

int ask0(int L, int R, int l, int r, int o) {
    if(!o) return 0;
    if(L <= l && r <= R) return sum0[o];
    int mid = (l + r) >> 1, ans = 0;
    if(L <= mid) ans += ask0(L, R, l, mid, ls[o]);
    if(mid < R) ans += ask0(L, R, mid + 1, r, rs[o]);
    return ans;
}

LL ask2(int L, int R, int l, int r, int o) {
    if(!o) return 0;
    if(L <= l && r <= R) return sum2[o];
    int mid = (l + r) >> 1;
    LL ans = 0;
    if(L <= mid) ans += ask2(L, R, l, mid, ls[o]);
    if(mid < R) ans += ask2(L, R, mid + 1, r, rs[o]);
    return ans;
}

LL askd(int L, int R, int l, int r, int o) {
    if(!o) return 0;
    if(L <= l && r <= R) return sumd[o];
    int mid = (l + r) >> 1;
    if(R <= mid) return askd(L, R, l, mid, ls[o]);
    if(mid < L) return askd(L, R, mid + 1, r, rs[o]);
    LL ans = askd(L, R, l, mid, ls[o]) + askd(L, R, mid + 1, r, rs[o]);
    if(ls[o] && rs[o]) {
        ans += large[ls[o]] * small[rs[o]];
    }
    return ans;
}

int getKpos(int k, int l, int r, int o) {
    if(l == r) return r;
    int mid = (l + r) >> 1;
    if(k <= sum0[ls[o]]) return getKpos(k, l, mid, ls[o]);
    else return getKpos(k - sum0[ls[o]], mid + 1, r, rs[o]);
}

void DFS(int x) {
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        fa[y][0] = x;
        DFS(y);
        rt[x] = merge(rt[x], rt[y]);
    }
    return;
}

inline void prework() {
    for(int i = 2; i <= tot; i++) pw[i] = pw[i >> 1] + 1;
    for(int j = 1; j <= pw[tot]; j++) {
        for(int i = 1; i <= tot; i++) {
            fa[i][j] = fa[fa[i][j - 1]][j - 1];
        }
    }
    return;
}

inline int getPos(int x, int Len) {
    int t = pw[tot];
    while(t >= 0 && len[fa[x][0]] >= Len) {
        if(len[fa[x][t]] >= Len) {
            x = fa[x][t];
        }
        t--;
    }
    return x;
}

inline LL getAns(int Len, int root) {
    
    if(Len == 1) return 0;
    
    int r1 = small[root], rn = large[root];
    int l1 = r1 - Len + 1, ln = rn - Len + 1;
    
    if(ask0(r1 + Len - 1, ln, 1, n, root)) {
        return 0;
    }
    LL ans = 0;
    if(r1 > ln) { /// cross 
        ans = sum2[root] - sumd[root] - 1ll * r1 * rn;
        LL temp = (r1 - ln);
        ans += (temp - 1) * temp / 2 + temp * (n - temp - 1);
    }
    else {
        int ql = ask0(1, r1 + Len - 2, 1, n, root), qr = ask0(1, ln, 1, n, root);
        int L = qr, R = ql;
        int rL = getKpos(L, 1, n, root), rR = getKpos(R, 1, n, root), nexr = getKpos(R + 1, 1, n, root);
        ans = 1ll * (r1 - rR + Len - 1) * (nexr - ln) + 1ll * rL * ln - 1ll * rR * ln;
        ans += ask2(rL + 1, rR, 1, n, root) - askd(rL, rR, 1, n, root);
    }
    return ans;
}

int main() {
    memset(small, 0x3f, sizeof(small));
    scanf("%d%d", &n, &q);
    scanf("%s", str + 1);
    for(int i = 1; i <= n; i++) {
        insert(str[i], i);
    }
    int p = 1;
    for(int i = 1; i <= n; i++) {
        int f = str[i] - '0';
        p = tr[p][f];
        ed[i] = p;
        //printf("i = %d p = %d 
", i, p);
    }
    for(int i = 2; i <= tot; i++) add(fail[i], i);
    DFS(1);
    prework();
    LL SUM = 1ll * (n - 1) * (n - 2) / 2;
    for(int i = 1, l, r; i <= q; i++) {
        scanf("%d%d", &l, &r);
        LL t = getAns(r - l + 1, rt[getPos(ed[r], r - l + 1)]);
        printf("%lld
", SUM - t);
    }
    return 0;
}