HDU Forgiving Matching

最新推荐文章于 2022-07-07 19:35:52 发布

Asiip

最新推荐文章于 2022-07-07 19:35:52 发布

阅读量137

点赞数

本文链接：https://blog.csdn.net/asiip/article/details/119334279

版权

FFT字符串匹配

本题题解

题目链接：Problem - 6975 (hdu.edu.cn)

题意：长度为n的字符串S和长度为m的字符串T匹配（m<n），*号可以充当万能符号，允许小于等于k个字符不相等。

输入格式：

样例数 K（1<=K<=100）

S串长度n T串长度m（1<=m<=n<=200 000）

S串

T串

输出：第i行表示K=i-1

知识点

FFT字符串匹配

参考：(5条消息) FFT总结及FFT在字符串匹配上的应用_十分残念的博客-CSDN博客

用FFT做字符串匹配！ - 知乎 (zhihu.com)

和kmp的区别：FFT适用于带通配符的单模式串匹配

kmp：单模式串匹配 AC自动机：多模式串匹配

带有通配符的字符串匹配

例子：P4173 残缺的字符串 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include<iostream>
#include<algorithm>
#include<math.h>
using namespace std;
#define N 2000005
#define mod 998244353
int m, n;
char s[N], t[N];
double A[N], B[N];
const double pi = acos(-1.0);
struct Complex 
{
    double r, i;
    Complex(double _r = 0, double _i = 0) { r = _r, i = _i; }
    Complex operator+ (const Complex& rhs) { return Complex(r + rhs.r, i + rhs.i); }
    Complex operator- (const Complex& rhs) { return Complex(r - rhs.r, i - rhs.i); }
    Complex operator* (const Complex& rhs) { return Complex(r * rhs.r - i * rhs.i, i * rhs.r + r * rhs.i); }
}a[N],b[N],P[N];
void rader(Complex F[], int len) { //len = 2^M,reverse F[i] with  F[j] j为i二进制反转  
    int j = len >> 1;
    for (int i = 1; i < len - 1; ++i) {
        if (i < j) swap(F[i], F[j]); // reverse  
        int k = len >> 1;
        while (j >= k) {
            j -= k;
            k >>= 1;
        }
        if (j < k) j += k;
    }
}
void FFT(Complex F[], int len, int t) {
    rader(F, len);
    for (int h = 2; h <= len; h <<= 1) {
        Complex wn(cos( -t*2*pi / h), sin(-t*2*pi/h));
        for (int j = 0; j < len; j += h) {
            Complex E(1, 0); //旋转因子  
            for (int k = j; k < j + h / 2; ++k) {
                Complex u = F[k];
                Complex v = E * F[k + h / 2];
                F[k] = u + v;
                F[k + h / 2] = u - v;
                E = E * wn;
            }
        }
    }
    if (t == -1) //IDFT  
        for (int i = 0; i < len; ++i)
            F[i].r /= len;
}

void FFT_Match(char* s1, char* s2, int m, int n)
{
    int len = 1;
    int mx = n + m;
    while (len <= mx) len <<= 1;
    reverse(s1, s1 + m);
    for (int i = 0; i < m; i++) A[i] = (s1[i] != '*') ? (s1[i] - 'a' + 1) : 0;
    for (int i = 0; i < n; i++) B[i] = (s2[i] != '*') ? (s2[i] - 'a' + 1) : 0;

    for (int i = 0; i < len; i++) a[i] = Complex(A[i] * A[i] * A[i], 0), b[i] = Complex(B[i], 0);
    FFT(a, len, 1); FFT(b, len, 1);
    for (int i = 0; i < len; i++) P[i] = (P[i] + a[i] * b[i]);

    for (int i = 0; i < len; i++) a[i] = Complex(A[i], 0), b[i] = Complex(B[i] * B[i] * B[i], 0);
    FFT(a, len, 1); FFT(b, len, 1);
    for (int i = 0; i < len; i++) P[i] = P[i] + a[i] * b[i];

    for (int i = 0; i < len; i++) a[i] = Complex(A[i] * A[i], 0), b[i] = Complex(B[i] * B[i], 0);
    FFT(a, len, 1); FFT(b, len, 1);
    for (int i = 0; i < len; i++) P[i] = P[i] - a[i] * b[i] * Complex(2, 0);

    FFT(P, len, -1);
    int cnt = 0;
    for (int i = m - 1; i < n; i++)
    {
        if (fabs(P[i].r) <= 1e-8)
            cnt++;
    }
    if (cnt == 0)
        cout <<0<< endl;
    else
    {
        cout << cnt << endl;
        for (int i = m - 1; i < n; i++)
        {
            if (fabs(P[i].r) <= 1e-7) 
                printf("%d ", i - m + 2);
        }
    }
}
int main()
{
    cin >> m >> n;
    cin >> t >> s;
    
    FFT_Match(t, s, m, n);
}

但是好奇怪不知道为什么eps改到1e-1才对。

本题题解

对于 S 的每个长度为 m 的子串，统计其与 T 匹配的位置数 fi，即可得到该子串被认为匹配的最小的k值。

假设没有通配符的存在，枚举 0 到 9 每个字符 c，那么如果 Si = Tj = c，则 fi−j 应该加上 1，可以翻转 T 串后通过 FFT 求出 f。

考虑通配符的影响，S一个子串与 T 通过通配符匹配的位置数 = S 对应子串中通配符的数+T 中通配符的数量 − 对应位置都是通配符的位置数量。S 对应子串中通配符的数量可以使用前缀和求得，对应位置都是通配符的位置数量同样可以通过 FFT 求得。


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e6 + 5;
const int num = 200002;
const double Pi = acos(-1.0);
int r[maxn];
int vis[maxn];
int T, n , m;
char s1[maxn],s2[maxn];
int ans[maxn] , cnt[maxn];
struct Complex{
    double x, y;
    Complex(double xx = 0, double yy = 0) : x(xx), y(yy) {}
    Complex operator+(Complex b){
        return Complex(x + b.x, y + b.y);
    }
    Complex operator-(Complex b){
        return Complex(x - b.x, y - b.y);
    }
    Complex operator*(Complex b){
        return Complex(x * b.x - y * b.y, x * b.y + y * b.x);
    }
};

// 最高n，m次， 0次为常数
Complex a[maxn], b[maxn];
Complex c[maxn];
void fft(Complex *cm, int cnum, int tag){
    for(int i =  0 ; i <= cnum - 1; i ++){
        if (i < r[i]){
            swap(cm[i], cm[r[i]]);
        }
    }
    for (ll mid = 1; mid < cnum; mid <<= 1){
        Complex wk = Complex(cos(2 * Pi / (2 * mid)), tag * sin(2 * Pi / (2 * mid)));
        for (ll j = 0; j < cnum; j += 2 * mid) //枚举 cnum/2*mid个全长段
        {
            Complex w(1, 0);
            for (ll k = 0; k < mid; k++) //每段里面进行fft，不是<=，因为只有一半，不能超出
            {
                Complex buf = w * cm[j + k + mid];
                cm[j + k + mid] = cm[j + k] - buf; //在这一步cm[j + k] = cm[j + k] + buf上，否则cm[j+k]已被更改
                cm[j + k] = cm[j + k] + buf;
                w = w * wk;
            }
        }
    }
}

int fft_init(int n){     //n是最高次幂
    int maxx = 1, bits = 0;
    while ((maxx) <= n) {
        maxx <<= 1;
        bits++;
    }
    for(int i = 0; i <= maxx - 1; i ++){
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (bits - 1)); //求二进制反转结果
    }
    return maxx;
}

void work(int maxx){
     fft(a , maxx , 1);
     fft(b , maxx , 1);
     for(int i = 0; i <= maxx; i ++){
        c[i] = a[i] * b[i];
     }
     fft(c , maxx , -1);
     for(int i = 0; i <= n - m; i ++){
        vis[i] = (c[i + 2 * m].x / maxx + 0.5);
        cnt[i] += vis[i];
     }
     for(int i = 0; i <= maxx; i ++){
        a[i].x = b[i].x = c[i].x = 0;
        a[i].y = b[i].y = c[i].y = 0;
     }
}

int main(){
   scanf("%d",&T);
   while(T--){
        scanf("%d%d",&n,&m);
        scanf("%s%s",s1 + 1 , s2 + 1);
        for(int i = 0; i <= n; i ++){
            cnt[i] = ans[i] = 0;
        }
        int maxx = fft_init(n + 2 * m);
        for(int now = 0; now <= 9; now ++){           //求 1 - 9的贡献
            for(int i = 1; i <= n; i ++){
                if(s1[i] == now + '0' || s1[i] == '*') a[m + i].x ++;
            }
            for(int i = 1; i <= m; i ++){
                if(s2[i] == now + '0') b[m - i].x ++;
            }
            work(maxx);
        }

        for(int i = 1; i <= n; i ++){      //求 * 的贡献
            a[m + i].x ++;
        }
        for(int i = 1; i <= m; i ++){
            if(s2[i] == '*') b[m - i].x ++;
        }
        work(maxx);

        for(int i = 0; i <= n - m; i ++){  //cnt[i]代表移动 i 位 后的匹配数
            ans[m - cnt[i]] ++;
        }

        for(int i = 0; i <= m; i ++){
            if(i) ans[i] += ans[i - 1];
            printf ("%d\n",ans[i]);
        }

   }
    return 0;
}