洛谷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 = ;
 const double eps = 1e-;

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

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

 inline void pushdown(int o) {
     if(tag[o]) {
         tag.set(o << );
         tag.set(o <<  | );
         large[o << ] = large[o <<  | ] = ;
         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) >> ;
     if(p <= mid) change(p, v, l, mid, o << );
     else change(p, v, mid + , r, o <<  | );
     large[o] = Max(large[o << ], large[o <<  | ]);
     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) >> , ans = ;
     pushdown(o);
     if(L <= mid) ans = getMax(L, R, l, mid, o << );
     if(mid < R) ans = Max(ans, getMax(L, R, mid + , r, o <<  | ));
     return ans;
 }

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

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

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

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

             f[] = (mat[] >= mid); /// ERROR : f[0] = mat[0]
             stk[head = top = ] = ;
             for(int i = ; i < Len; i++) {
                 f[i] = f[i - ];
                 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 \n", mid, f[Len - 1]);
             if( * f[Len - ] >=  * Len) {
                 l = mid;
             }
             else {
                 r = mid - ;
             }
         }
         printf("%d\n", r);
         memset(str, , Len * sizeof(char));
     }

     return ;
 }

AC代码

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