UVALive 4671 (LA 4671) K-neighbor substrings (2009年合肥) FFT

题目大意：

就是现在定义两个字符串之间的Hamming距离指的是两个相同长度的字符串对应位置字符不同的位置数量, 例如“aab"和”bab"的Hamming距离是1因为第一个字符不一样

现在给出K个两个只包含字符'a', 'b'的字符串A和B, 求A的子串中与B的Hamming距离不超过K的本质不同的子串数量, 即如果"aaa"在A中出现两次及以上且满足条件也只记一次

大致思路：

首先这个题之前以为是可以用后缀自动机做的题然后怎么想都超时了, 后来留着这个坑到现在....

这个题实际上是比较巧妙的用了FFT算法, 对于两个字符串, 用多项式来表示, 因为字符只有‘a'和’b', 用多项式的系数为0或者1表示当前这一个位置是'a'还是'b', 首先如果用1表示‘a', 0表示'b'的话对于两个串A和B怎么判断其有多少位不同呢? 其实可以反过来考虑, 考虑其有多少位都是'a', 多少位都是'b', 我们将串B反过来写, 然后和A做多项式乘法, 那么只有当两者都是’a'(这里记的是'a'为1)时多项式多对应那一项结果的系数会+1, 然后我们在把'b'记做1, 'a'记做0, 再来一次可以得到多少位置都是'b', 这样就能得到对应一段A的子串和B的相同位置个数了, 由于将B反向了再构造的多项式, 和A相乘, 得到的相同位置数会在结果的同一个次幂的项的系数上积累, 所以完成乘法之后根据结果多项式的系数即可知道A哪个对应位置的子串和B有几个相同的字符, 对于字串相同的, Hash判断一下即可

总之这个题就是注意两点, 字符只有'a'和'b', 可以对应为0, 1, 而将B反向, 构造A和B的多项式作乘法能将相同位置的贡献聚集到结果的同一次幂的项上

不过这个题可能是我FFT写的常数有些大的原因, 刚好在时限附近卡过....

代码如下：

Result  :  Accepted     Memory  :  0 KB     Time  :  2945 ms

/*
 * Author: Gatevin
 * Created Time:  2015/7/15 12:50:38
 * File Name: UVALive4671.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;
typedef unsigned long long ulint;

const double PI = acos(-1.0);

ulint seed = 500009uLL;
ulint H[100010];
ulint xp[100010];
set<ulint> S;

void initHash(char* s, int len)
{
    H[0] = s[0] - 'a' + 1;
    for(int i = 1; i < len; i++)
        H[i] = H[i - 1]*seed + s[i] - 'a' + 1;
}

ulint askHash(int l, int r)
{
    if(l == 0) return H[r];
    return H[r] - H[l - 1]*xp[r - l + 1];
}


struct Complex
{
    double real, image;
    Complex(double _real, double _image)
    {
        real = _real;
        image = _image;
    }
    Complex(){}
};

Complex operator + (const Complex &c1, const Complex &c2)
{
    return Complex(c1.real + c2.real, c1.image + c2.image);
}

Complex operator - (const Complex &c1, const Complex &c2)
{
    return Complex(c1.real - c2.real, c1.image - c2.image);
}

Complex operator * (const Complex &c1, const Complex &c2)
{
    return Complex(c1.real*c2.real - c1.image*c2.image, c1.real*c2.image + c1.image*c2.real);
}

int rev(int id, int len)
{
    int ret = 0;
    for(int i = 0; (1 << i) < len; i++)
    {
        ret <<= 1;
        if(id & (1 << i)) ret |= 1;
    }
    return ret;
}

Complex A[266000];
void FFT(Complex* a, int len, int DFT)
{
    for(int i = 0; i < len; i++)
        A[rev(i, len)] = a[i];
    for(int s = 1; (1 << s) <= len; s++)
    {
        int m = (1 << s);
        Complex wm = Complex(cos(DFT*2*PI/m), sin(DFT*2*PI/m));
        for(int k = 0; k < len; k += m)
        {
            Complex w = Complex(1, 0);
            for(int j = 0; j < (m >> 1); j++)
            {
                Complex t = w*A[k + j + (m >> 1)];
                Complex u = A[k + j];
                A[k + j] = u + t;
                A[k + j + (m >> 1)] = u - t;
                w = w*wm;
            }
        }
    }
    if(DFT == -1) for(int i = 0; i < len; i++) A[i].real /= len, A[i].image /= len;
    for(int i = 0; i < len; i++) a[i] = A[i];
    return;
}

char sA[100010];
char sB[100010];
int K;

Complex a[266000];
Complex b[266000];
Complex sameA[266000];
Complex sameB[266000];

int main()
{
    xp[0] = 1;
    for(int i = 1; i <= 100000; i++)
        xp[i] = xp[i - 1]*seed;
    int cas = 1;
    while(scanf("%d", &K), K != -1)
    {
        gets(sA);
        gets(sA);
        gets(sB);
        int lenA = strlen(sA);
        int lenB = strlen(sB);
        if(lenB > lenA)
        {
            puts("0");
            continue;
        }
        for(int i = 0; i < lenA; i++)
            a[i] = Complex(sA[i] - 'a', 0);
        for(int i = 0; i < lenB; i++)
            b[lenB - i - 1] = Complex(sB[i] - 'a', 0);
        //先'a'记为0, 'b'即为1做乘法, 得到串A每一段和B对应位置都为b的数量
        int len = 1;
        while(len <= lenA) len <<= 1;
        len <<= 1;
        for(int i = lenA; i < len; i++)
            a[i] = Complex(0, 0);
        for(int i = lenB; i < len; i++)
            b[i] = Complex(0, 0);
        FFT(a, len, 1);
        FFT(b, len, 1);
        for(int i = 0; i < len; i++)
            sameB[i] = a[i]*b[i];
        FFT(sameB, len, -1);
        
        //接下来'a'记为1, '0'记为1做乘法, 得到A每一段和B对应都为a的数量
        for(int i = 0; i < lenA; i++)
            a[i] = Complex('b' - sA[i], 0);
        for(int i = 0; i < lenB; i++)
            b[lenB - i - 1] = Complex('b' - sB[i], 0);
        for(int i = lenA; i < len; i++)
            a[i] = Complex(0, 0);
        for(int i = lenB; i < len; i++)
            b[i] = Complex(0, 0);
        FFT(a, len, 1);
        FFT(b, len, 1);
        for(int i = 0; i < len; i++)
            sameA[i] = a[i]*b[i];
        FFT(sameA, len, -1);
        
        initHash(sA, lenA);
        S.clear();
        for(int pow = lenB - 1; pow < lenA; pow++)//结果的x^(pow)处的系数
            if(lenB - (int)(sameA[pow].real + 0.5) - (int)(sameB[pow].real + 0.5) <= K)
                S.insert(askHash(pow - lenB + 1, pow));
        printf("Case %d: %d\n", cas++, (int)S.size());
    }
    return 0;
}