【BZOJ4259】 残缺的字符串

Description

很久很久以前，在你刚刚学习字符串匹配的时候，有两个仅包含小写字母的字符串A和B，其中A串长度为m，B串长度为n。可当你现在再次碰到这两个串时，这两个串已经老化了，每个串都有不同程度的残缺。

你想对这两个串重新进行匹配，其中A为模板串，那么现在问题来了，请回答，对于B的每一个位置i，从这个位置开始连续m个字符形成的子串是否可能与A串完全匹配?

Input

第一行包含两个正整数m,n(1<=m<=n<=300000)，分别表示A串和B串的长度。

第二行为一个长度为m的字符串A。

第三行为一个长度为n的字符串B。

两个串均仅由小写字母和*号组成，其中*号表示相应位置已经残缺。

Output

第一行包含一个整数k，表示B串中可以完全匹配A串的位置个数。

若k>0，则第二行输出k个正整数，从小到大依次输出每个可以匹配的开头位置（下标从1开始）。

Sample Input

3 7
a*b
aebr*ob

Sample Output

2
1 5

HINT

 

Source

By Claris

Solution

对于每个字母的权值就设为1~26。*的权值设为0。两个字符可以匹配当且仅当A_i∗B_j∗(A_i−B_j )^2等于0。那么我们将这个式子展开，展开以后的每一项分别用FFT计算即可。

 #include <cstdio>
 #include <algorithm>
 #include <cmath>
 #include <cstring>

 #define R register
 #define maxn 1048576
 typedef long double db;
 const db pi = acosl(-);
 char A[maxn], B[maxn];
 struct Complex {
     db x, y;
     inline Complex operator - (const Complex &that) const {return (Complex) {x - that.x, y - that.y};}
     inline Complex operator * (const Complex &that) const {return (Complex) {x * that.x - y * that.y, x * that.y + y * that.x};}
     inline void operator += (const Complex &that) {x += that.x; y += that.y;}
 } w[maxn];
 int N;
 void init()
 {
     R int h = N >> ;
     for (R int i = ; i < h; ++i) w[i + h] = (Complex) {cos( * pi / N * i), sin( * pi / N * i)};
     for (R int i = h; i--; ) w[i] = w[i << ];
 }
 void bit_reverse(R Complex *a, R Complex *b)
 {
     for (R int i = ; i < N; ++i) b[i] = a[i];
     for (R int i = , j = ; i < N; ++i)
     {
         i > j ? std::swap(b[i], b[j]),  : ;
         for (R int l = N >> ; (j ^= l) < l; l >>= );
     }
 }
 void dft(R Complex *a)
 {
     for (R int l = , m = ; m != N; l <<= , m <<= )
         for (R int i = ; i < N; i += l)
             for (R int j = ; j < m; ++j)
             {
                 R Complex tmp = a[i + j + m] * w[j + m];
                 a[i + j + m] = a[i + j] - tmp;
                 a[i + j] += tmp;
             }
 }
 Complex a[maxn], b[maxn], ta[maxn], tb[maxn], tc[maxn], ans[maxn];
 int aa[maxn], bb[maxn];
 int main()
 {
     R int la, lb;
     scanf("%s%s", A, B);
     la = strlen(A); lb = strlen(B);
     for (N = ; N < (la + lb); N <<= );
     init();
     std::reverse(A, A + la);
     for (R int i = ; i < la; ++i) A[i] == '*' ?  : aa[i] = A[i] - 'a' + ;
     for (R int i = ; i < lb; ++i) B[i] == '*' ?  : bb[i] = B[i] - 'a' + ;

     for (R int i = ; i < la; ++i) a[i].x = aa[i] * aa[i] * aa[i], a[i].y = ;
     for (R int i = ; i < lb; ++i) b[i].x = bb[i], b[i].y = ;
     bit_reverse(a, ta); bit_reverse(b, tb);
     dft(ta); dft(tb);
     for (R int i = ; i < N; ++i) ans[i] += (ta[i] * tb[i]);

     for (R int i = ; i < la; ++i) a[i].x = - * aa[i] * aa[i], a[i].y = ;
     for (R int i = ; i < lb; ++i) b[i].x = bb[i] * bb[i], b[i].y = ;
     bit_reverse(a, ta); bit_reverse(b, tb);
     dft(ta); dft(tb);
     for (R int i = ; i < N; ++i) ans[i] += (ta[i] * tb[i]);

     for (R int i = ; i < la; ++i) a[i].x = aa[i], a[i].y = ;
     for (R int i = ; i < lb; ++i) b[i].x = bb[i] * bb[i] * bb[i], b[i].y = ;
     bit_reverse(a, ta); bit_reverse(b, tb);
     dft(ta); dft(tb);
     for (R int i = ; i < N; ++i) ans[i] += (ta[i] * tb[i]);

     std::reverse(ans + , ans + N);
     bit_reverse(ans, tc);
     dft(tc);
 //    for (R int i = 0; i < N; ++i) printf("%lf %lf\n", tc[i].x, tc[i].y);
     for (R int i = la - ; i < lb; ++i) if (fabs(tc[i].x / N) < 0.5) printf("%d ", i - la + );
     return ;
 }
 /*
 399906 399924 399942 399960 399978 399996
 */

FFT

其实这题的数据用bitset是可以水过的。不过可以卡。然后我优化了一发常数就只是最慢的数据本机3s以内了。我把代码放在这里欢迎大家来hack!  O(∩_∩)O~~

 #include <cstdio>
 #include <cstring>
 #include <bitset>
 #include <algorithm>

 #define R register
 #define maxn 500010
 #define maxs 15635
 //#define inline
 char A[maxn], B[maxn];
 /*inline bool eq(R char a, R char b)
 {
     return a == b || a == '*' || b == '*';
 }*/
 typedef unsigned uint;
 int len;

 #define set(v, x) (v[x >> 5] |= 1u << (x & 31))
 #define query(v, x) ((1u << (x & 31)) & v[x >> 5])
 uint p[][][maxs];
 uint aph[][maxs], ans[maxs];
 inline void init(R int c)
 {
     R uint *t = p[c][], *tt;
     for (R int i = ; i <= len; ++i) t[i] = aph[c][i];
     for (R int i = ; i < ; ++i)
     {
         t = p[c][i]; tt = p[c][i - ];
         for (R int j = ; j <= len; ++j)
             t[j] = ((tt[j] >> ) | ((tt[j + ] & 1u) << ));
     }
 }
 int cnt;
 inline void bit_and(R int c, R int l)
 {
     R int fir = l >> ; R uint *t = p[c][l & ];
     R int i = fir, j = ;
     for (; i +  < len; i += , j += )
     {
         ans[j] &= t[i];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
         ans[j + ] &= t[i + ];
     }
     for (; i <= len; ++i, ++j) ans[j] &= t[i];
 }

 //std::bitset<maxn> aph[26], ans;
 int fail[maxn];
 int r[maxn];
 inline bool cmp(R int a, R int b) {return A[a] < A[b] || (A[a] == A[b] && (a & ) < (b & ));}
 int main()
 {
 //    freopen("str.in", "r", stdin);
 //    freopen("str.out", "w", stdout);
     scanf("%s%s", A, B);
     R int la = strlen(A), lb = strlen(B);
     len = lb >> ;
     R int xcnt = ;
     for (R int i = ; i < la; ++i) xcnt += A[i] == '*';
     for (R int i = ; i < lb; ++i) xcnt += B[i] == '*';
     /*if (!xcnt)
     {
         fail[1] = 0;
         for (R int i = la; i; --i) A[i] = A[i - 1];
         for (R int i = lb; i; --i) B[i] = B[i - 1];
         for (R int i = 2, p = 0; i <= la; ++i)
         {
             while (p && A[p + 1] != A[i]) p = fail[p];
             A[p + 1] == A[i] ? ++p : 0;
             fail[i] = p;
         }
         for (R int i = 1, p = 0; i <= lb; ++i)
         {
             while (p && A[p + 1] != B[i]) p = fail[p];
             A[p + 1] == B[i] ? ++p : 0;
             if (p == la)
             {
                 printf("%d ", i - la + 1);
                 p = fail[p];
             }
         }
         puts("");
         return 0;
     }*/
     for (R int i = ; i < lb; ++i)
     {
         if (B[i] != '*') set(aph[B[i] - 'a'], i);
         else for (R int j = ; j < ; ++j) set(aph[j], i);
         set(ans, i);
     }
     for (R int i = ; i < ; ++i) init(i);
 //    fprintf(stderr, "%d %d\n", '*', 'a');
     for (R int i = ; i < la; ++i) r[i] = i;
     std::sort(r, r + la, cmp);
     for (R int i = ; i < la; ++i)
         if (A[r[i]] != '*')
             bit_and(A[r[i]] - 'a', r[i]);
 //            ans &= (aph[A[i] - 'a'] >> i);
     for (R int i = ; i + la -  < lb; ++i) if (query(ans, i)) printf("%d ", i + ); puts("");
     return ;
 }

bitset