ural 1996. Cipher Message 3 KMP+FFT

     长度为N,M的两个字符串，每个串的单位元素是一个8位的01串，现在允许修改第二个串的每个单位元素的最后一位（0变1或者1变0），问最少要修改几个字符可以使得第二个串在第一个串中匹配，并输出最靠前的匹配位置。

      首先把单位元素分成前七位和最后一位两部分，前七位可以看成一个0-127的数存起来，得到前七位组成两个串A,B和最后一位组成的两个串a,b。然后对A,B跑一边KMP，剩下的就是在匹配的位置中，找一个对应位置a,b的最小海明距离。N,M最大都是250000，暴力找显然要超..直接拿a,b乘起来得到的结果好像也没什么规律...但是如果把b串翻转后，再把a,b相乘，得到的就是从b[m-1]=a[0]开始到b[0]=a[n-1]，从b[0]--b[m-1]在对应的a上共有多少个共同的1，至于为什么，在草纸上列出相乘的竖式，就会发现一位一位乘出m行积后在相加时，对应的每一列其实就是b翻转前同a中相应位置的字符&运算和的和，然后把a,b取反，再乘一边就能得到每位开始共同的0的个数，之后枚举下kmp的得到的答案，找一下相同的1+相同的0的最大值的位置就行了。

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef long long ll;
vector ans;

const double PI = acos(-1.0);
struct comp
{
    double r,i;
    comp(double rt=0,double it=0)
    {
        r=rt;
        i=it;
    }
    comp operator +(const comp& b)
    {
        return comp(r+b.r,i+b.i);
    }
    comp operator -(const comp &b)
    {
        return comp(r-b.r,i-b.i);
    }
    comp operator *(const comp &b)
    {
        return comp(r*b.r-i*b.i,r*b.i+i*b.r);
    }
};

void change(comp y[],int len)//二进制转置--雷德算法
{
    int i,j,k;
    for(i = 1, j = len/2;i < len-1;i++)
    {
        if(i < j)swap(y[i],y[j]);
        k = len/2;
        while( j >= k)
        {
            j -= k;
            k /= 2;
        }
        if(j < k)j += k;
    }
}

void fft(comp y[],int len,int on)
/* on=1 DFT 把一个多项式的系数向量转化为点集表示；
on=-1,IDFT 把一个点集转化成多项式的系数向量*/
{
    change(y,len);
    for(int h = 2;h <= len;h <<= 1)
    {
        comp wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
        for(int j = 0;j < len;j += h)
        {
            comp w(1,0);
            for(int k = j;k < j+h/2;k++)
            {
                comp u = y[k];
                comp t = w*y[k+h/2];
                y[k] = u+t;
                y[k+h/2] = u-t;
                w = w*wn;
            }
        }
    }
    if(on == -1)
        for(int i = 0;i < len;i++)
            y[i].r /= len;
}

const int maxn=8*250010;
int n,m,k,p,q;
int s1[255000],s2[255010];
char a[250010],b[250010];
char ss[20];
int fail[maxn];
comp x[610000],y[610000],z[610000];
int zero[610000],one[610000];

void getFail(int* P,int* f)
{

    f[0]=0;
    f[1]=0;
    for (int i=1; i>1); i++)
    swap(b[i],b[m-i-1]);

    int len1=max(n,m);
    int len=1;
    while(len<2*len1) len<<=1;

    for (int i=0; i