洛谷P4022 熟悉的文章

题意：给定一个串集合s，每次给定一个串t，询问一个最大的L，使得存在一种划分能把t划分成若干个子串， 其中好的子串总长不小于0.9|t|。好的子串定义为长度不小于L且是s中某一个串的子串。

解：发现这个L可以二分。如果一个L满足那么小一点的L也满足。考虑如何check。

可以求最长的总好的子串长度，然后看是否大于0.9。

这样就能想到DP了。设f[i]表示t[0:i]能划分出的最长好的子串。转移就是考虑第i是否是一个好的子串的结尾。如果是就枚举卡开头，否则就是f[i - 1]。

这个每个位置都有一个最长能匹配的长度mat[i]，然后我们以i结尾的好的子串长度限制就是mat[i] ~ mid。

我们发现转移过来的两个限制，右边界显然是每次 + 1的，而左边界单调递增。具体来说，如果i结尾的最长匹配是[k, i]，那么i - 1结尾的最长匹配不会比[k, i - 1]还短。

所以用广义SAM搞出来mat，然后二分 + 单调队列优化DP。

注意开头的时候f[0]是mat[0] >= mid。

#include <bits/stdc++.h>

const int N = 1000010;
const double eps = 1e-8;

int tr[N][2], fail[N], len[N], tot = 1;
int mat[N], f[N];
int stk[N], top, head;
char str[N];

inline int Max(const int &a, const int &b) {
    return a > b ? a : b;
}

inline int split(int p, int f) {
    int Q = tr[p][f], nQ = ++tot;
    len[nQ] = len[p] + 1;
    fail[nQ] = fail[Q];
    fail[Q] = nQ;
    memcpy(tr[nQ], tr[Q], sizeof(tr[Q]));
    while(tr[p][f] == Q) {
        tr[p][f] = nQ;
        p = fail[p];
    }
    return nQ;
}

inline int insert(int f, int p) {
    if(tr[p][f]) {
        int Q = tr[p][f];
        if(len[Q] == len[p] + 1) {
            return Q;
        }
        else {
            return split(p, f);
        }
    }
    int np = ++tot;
    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 {
            fail[np] = split(p, f);
        }
    }
    return np;
}

int large[N << 2];
std::bitset<N * 4> tag;

inline void pushdown(int o) {
    if(tag[o]) {
        tag.set(o << 1);
        tag.set(o << 1 | 1);
        large[o << 1] = large[o << 1 | 1] = 0;
        tag.reset(o);
    }
    return;
}

void change(int p, int v, int l, int r, int o) {
    if(l == r) {
        tag.reset(o);
        large[o] = v;
        return;
    }
    pushdown(o);
    int mid = (l + r) >> 1;
    if(p <= mid) change(p, v, l, mid, o << 1);
    else change(p, v, mid + 1, r, o << 1 | 1);
    large[o] = Max(large[o << 1], large[o << 1 | 1]);
    return;
}

int getMax(int L, int R, int l, int r, int o) {
    if(L <= l && r <= R) {
        return large[o];
    }
    int mid = (l + r) >> 1, ans = 0;
    pushdown(o);
    if(L <= mid) ans = getMax(L, R, l, mid, o << 1);
    if(mid < R) ans = Max(ans, getMax(L, R, mid + 1, r, o << 1 | 1));
    return ans;
}

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; i++) {
        scanf("%s", str);
        int len = strlen(str), last = 1;
        for(int j = 0; j < len; j++) {
            last = insert(str[j] - '0', last);
        }
        memset(str, 0, len * sizeof(char));
    }

    for(int A = 1; A <= n; A++) {
        scanf("%s", str);
        int Len = strlen(str);

        int p = 1, lenth = 0;
        for(int i = 0; i < Len; i++) {
            int f = str[i] - '0';
            while(p && !tr[p][f]) {
                p = fail[p];
                lenth = len[p];
            }
            if(tr[p][f]) {
                p = tr[p][f];
                lenth++;
            }
            else {
                p = 1, lenth = 0;
            }
            mat[i] = lenth;
            //printf("mat %d = %d 
", i, mat[i]);
        }

        int l = 0, r = Len;
        while(l < r) {
            int mid = (l + r + 1) >> 1;

            f[0] = (mat[0] >= mid); /// ERROR : f[0] = mat[0]
            stk[head = top = 1] = 0;
            for(int i = 1; i < Len; i++) {
                f[i] = f[i - 1];
                int L = i - mat[i], R = i - mid;
                while(head <= top && f[R] - R >= f[stk[top]] - stk[top]) {
                    --top;
                }
                stk[++top] = R;
                while(head < top && stk[head] < L) {
                    ++head;
                }
                if(L <= stk[head] && stk[head] <= R) {
                    f[i] = Max(f[i], f[stk[head]] + i - stk[head]);
                }
            }
            //printf("mid = %d  f = %d 
", mid, f[Len - 1]);
            if(10 * f[Len - 1] >= 9 * Len) {
                l = mid;
            }
            else {
                r = mid - 1;
            }
        }
        printf("%d
", r);
        memset(str, 0, Len * sizeof(char));
    }

    return 0;
}

我非常傻，一开始写的是个线段树，没看出来单调性...