FFT抄袭笔记

你看我都不好意思说是学习笔记了，毕竟\(FFT\)我怎么可能学得会

那就写一篇抄袭笔记吧ctrl+c真舒服

先从多项式说起吧

1.多项式

我们定义一个多项式

\[F(x)=\sum_{i=0}^{n-1}a_ix^i
\]

这就是一个\(n-1\)次的多项式了

比如说\(F(x)=x^3+2x^2+x+1\)就是一个三次的多项式了

我们还可以把多项式理解成函数，比如说上面那个多项式\(F(2)=2^3+2\times2^2+2+1=19\)

很休闲吧，我会的也就这么多了

之后多项式还有两种表达形式

系数表示法，就是把系数存下来啊，上面那个多项式就是\(\{1,2,1,1\}\)
点值表示法，任何一个\(n-1\)的多项式都可以被\(n\)个点完全表示出来，这个好像是拉格朗日插值里的内容了吧，比如上面那个多项式我们可以用\((0,1),(1,5),(2,19),(3,49)\)来表示

这两种表示方法当然是可以互相转化的，系数转点值我们直接暴力找出\(n\)个点带进去，点值转系数我们直接列出方程来高斯消元就好了

但是一个是\(O(n^2)\)的，一个是\(O(n^3)\)的

还有一个东西是多项式乘法，比如说两个多项式\(G(x),H(x)\)

有

\[G(x)=\sum_{i=0}^{n-1}a_ix^i
\]

\[H(x)=\sum_{i=0}^{m-1}b_ix^i
\]

那么

\[G\times H(x)=\sum_{i=0}^{n+m-2}\sum_{j=0}^ia_{j}b_{i-j}x^i
\]

这个东西直接来做也是\(O(n^2)\)的，但是如果给出的是两个点值表示的多项式，那么在\(O(n)\)的时间内就可以做了，就是横坐标相等的点纵坐标直接乘起来

而\(FFT\)就是为了解决上面的问题的

2.虚数和单位根

再来扯一扯虚数

就是数轴上根本不存在的数了

一个虚数通常长这个样子\(a+bi\)，其中\(i=\sqrt{-1}\)

这个东西长得这么奇怪肯定不在数轴上了，它飘了起来

比如说\(a+bi\)就对应平面上的\((a,b)\)这个点

是不是很像向量啊，我所以虚数的运算跟向量差不多

\[(a+bi)+(c+di)=(a+c)+(b+d)i
\]

\[(a+bi)-(c+di)=(a-c)+(b-d)i
\]

\[(a+bi)\times(c+di)=ac+adi+bci+bdi^2=(ac-bd)+(ad+bc)i
\]

\[\frac{a+bi}{c+di}=\frac{(a+bi)\times (c-di)}{(c+di)\times (c-di)}=\frac{ac+bd}{c^2+d^2}+\frac{bc-ad}{c^2+d^2}i
\]

我们可以定义结构体来进行虚数的操作

struct complex

{

	double r,c;

	complex (double r=0,double c=0):r(r),c(c) {};

};

complex operator +(complex a,complex b) {return complex(a.r+b.r,a.c+b.c);}

complex operator -(complex a,complex b) {return complex(a.r-b.r,a.c-b.c);}

complex operator *(complex a,complex b) {return complex(a.r*b.r-a.c*b.c,a.r*b.c+a.c*b.r);}

complex operator /(complex a,complex b) {return complex((a.r*b.r+a.c*b.c)/(b.r*b.r+b.c*b.c),(a.c*b.r-a.r*b.c)/(b.r*b.r+b.c*b.c));}

好像上面最长的虚数除法在\(FFT\)中并不会用到

除了\(a+bi\)这种表示方法，虚数还可以通过模长和幅角的表示方法

模长就是\(a+bi\)在平面上对应的点到原点的距离，就是\(l=\sqrt{a^2+b^2}\)

幅角就是和原点连线与\(x\)轴的夹角，就是\(\theta =cot\frac{b}{a}\)

于是\(a+bi=cos\theta l+sin\theta l\times i\)

根据一些我背不过的三角函数运算法则，虚数相乘的几何意义就是模长相乘，幅角相加

之后是神奇的单位根

首先对于半径为一的圆，我们把它的圆心定为坐标原点这样的圆叫做单位圆

神奇的单位根来源于这样一个方程

\[a^n=1
\]

注意这里的\(a\)可是一个虚数

\(1\)自然也可以被看成一个虚数，模长为\(1\)，幅角为\(2\pi\)的虚数

所有说\(a\)的模长\(l\)，幅角\(\theta\)肯定会满足如下的性质

\[l^n=1,2\pi|n\theta(2\pi k=n\theta)
\]

所以

\[l=1,\theta=\frac{2\pi k}{n}
\]

对于这样的虚数我们就叫做\(n\)次单位根，对于上面那一个幅角为\(\frac{2\pi k}{n}\)的记为\(\omega^k_n\)

由于模长都是\(1\)，所以单位根就分部在单位圆上，而且还将单位圆\(n\)等分

单位根有一些非常好的性质这些都是从慎老师那里抄来的

\(\omega_{2n}^{2k}=\omega_n^k\)

这个非常显然，因为模长都是\(1\)，而\(\frac{2\pi\times 2k}{2n}=\frac{2\pi k}{n}\)

如果\(n\)是偶数，\(\omega_{n}^k=-\omega_{n}^{k+n/2}\)

其实还有更为重要的性质\(\omega_{n}^k \times \omega_{n}^j=\omega_{n}^{k+j}\)

这里的话\(\omega_n^{k+n/2}=\omega_n^k\times \omega_{n}^{n/2}\)

\(\omega_{n}^{n/2}\)并不是一个虚数，而是\(-1\)，所以得证

\((\omega_n^k)^j=\omega_{n}^{kj}\)

好像从上面来看这个东西也不难理解啊

\(\omega_n^k=\omega_n^{k\%n}\)

这个不就是多转了一圈吗

之后就是单位根的求解方法，显然\(\omega_{n}^x=\omega_{n}^{x-1+1}=\omega_{n}^{x-1}\times \omega_{n}^1\)

所以我们知道了\(\omega_n^1\)就可以推出来所有的\(n\)次单位根了

而\(\omega_n^1\)的幅角是\(\frac{2\pi}{n}\)，所以\(\omega_n^1=cos\frac{2\pi}{n}+sin\frac{2\pi}{n}i\)

3.DFT

现在才是主角登场了

我们要将两个多项式乘起来显然靠系数表示并不能成功，因为根本没有办法优化

但是点值表示的话却可以在\(O(n)\)时间内完成乘法，所以我们得先试图转化成点值表示法

但是这又是\(O(n^2)\)的了

但是我们带进去的数如果是单位根呢，这样会不会有一些奇妙的性质呢

\(DFT\)就是在\(O(nlogn)\) 时间内把系数变成点值的

对于一个多项式\(F(x)\)，我们先将其进行奇偶分类

\(G(x)\)来存奇数项，\(H(x)\)用来存偶数项

使得\(F(x)=xG(x^2)+H(x^2)\)

比如说\(F(x)=3x^3+2x^2+x+4\)

那么\(G(x)=3x+1\)，\(H(x)=2x+4\)

如果我们对于一个\(n-1\)次多项式代入了\(n\)次单位根

那么

\[F(\omega_{n}^k)=\omega_{n}^kG((\omega_{n}^k)^2)+H((\omega_{n}^k)^2)
\]

我们发现\((\omega_{n}^k)^2=\omega_{n}^{2k}\)的幅角是\(\frac{2\pi\times 2k}{n}=\frac{2\pi k}{\frac{n}{2}}\)

也就是说\((\omega_{n}^k)^2=\omega_{n/2}^k\)

那么

\[F(\omega_{n}^{k})=\omega_{n}^{k}G(\omega_{n/2}^{k})+H(\omega_{n/2}^{k})
\]

但是如果\(k>n/2\)的话我们还得取个\(\%\)

所以

\[F(\omega_n^k)=\omega_n^kG(\omega_{n/2}^{k-n/2})+H(\omega_{n/2}^{k-n/2})
\]

看到反复\(/2\)了吗，这样算下去复杂度不就是\(O(nlogn)\)了吗

突然发现和慎老师的柿子不一样了

这是慎老师的柿子

\[F(\omega_{n}^k)=\omega_{n}^kG(\omega_{n/2}^k)+H(\omega_{n/2}^k)(k<n/2)
\]

\[F(\omega_{n}^k)=-\omega_{n}^kG(\omega_{n/2}^k)+H(\omega_{n/2}^k)(k>=n/2)
\]

好像也非常有道理的样子呢

懒得写了，抄一个慎老师的板子吧

void DFT (complex *f,int len)

{

	if(!len) return ;

	complex g[len+1],h[len+1];

	for (R i=0;i<=len;++i)

		g[i]=f[i<<1|1],h[i]=f[i<<1];

	DFT(g,len>>1);

	DFT(h,len>>1);

	complex og1,og;

	len<<=1;

	og=complex(1,0);

	og1=complex(cos(Pi*2/len),sin(Pi*2/len));

	for (R k=0;k<len/2;++k)

	{

		f[k]=og*g[k]+h[k];

		f[k+len/2]=h[k]-og*g[k];

		og=og1*og;

	}

}

4.IDFT

我们已经把系数变成点值了，之后我们就可以把点值大力乘起来了，这样就是两个多项式相乘之后的点值表示了

现在的问题变成了如何快速的把一个点值再转化成系数形式

\[\begin{bmatrix}
&(\omega_{n}^{0})^{0}&(\omega_{n}^{0})^{1}&\cdots&(\omega_{n}^{0})^{n-1}&\\
&(\omega_{n}^{1})^{0}&(\omega_{n}^{1})^{1}&\cdots&(\omega_{n}^{1})^{n-1}\\
&\vdots&\vdots&\ddots&\vdots\\
&(\omega_{n}^{n-1})^{0}&(\omega_{n}^{n-1})^{1}&\cdots&(\omega_{n}^{n-1})^{n-1}\\
\end{bmatrix}
\begin{bmatrix}
&F[0]&\\
&F[1]\\
&\vdots\\
&F[n-1]
\end{bmatrix}
=\begin{bmatrix}
&y_{0}&\\
&y_{1}\\
&\vdots\\
&y_{n-1}
\end{bmatrix}\]

我们把这个写成矩阵的形式

设上面那三个矩阵分别为\(A,B,C\)

也就有\(A\times B=C\)，我们现在已经求出了\(C\)这个矩阵，需要求出\(B\)这个矩阵

显然\(B=C\times A^{-1}\)

我们甚至需要对那个矩阵求一个逆

那么恭喜成功优化到了n^3级别

但是\(A^{-1}\)并不需要求逆，因为我们提前知道它是这个样子

\[\begin{bmatrix}
&\frac{1}{n}(\omega_{n}^{0})^{0}&\frac{1}{n}(\omega_{n}^{0})^{1}&\cdots&\frac{1}{n}(\omega_{n}^{0})^{n-1}&\\
&\frac{1}{n}(\omega_{n}^{-1})^{0}&\frac{1}{n}(\omega_{n}^{-1})^{1}&\cdots&\frac{1}{n}(\omega_{n}^{-1})^{n-1}\\
&\vdots&\vdots&\ddots&\vdots\\
&\frac{1}{n}(\omega_{n}^{-n+1})^{0}&\frac{1}{n}(\omega_{n}^{-n+1})^{1}&\cdots&\frac{1}{n}(\omega_{n}^{-n+1})^{n-1}\\
\end{bmatrix}
\]

先不管为什么，我们如果把这个矩阵和刚才得到的点值做一次矩阵乘法，就能得到系数式了

其实就是把得到的点值当做系数再来做一遍系数转点值就好了

发现这里和\(DFT\)唯一的不同就是我们的单位根不同了，一个是\(\omega_n^1\)一个是\(\omega_n^{-1}\)，其余部分都是一模一样的，所以甚至我们可以把\(DFT\)和\(IDFT\)写在一起

void FFT (complex *f,int len,int v)

{

	if(!len) return ;

	complex g[len+1],h[len+1];

	for (R i=0;i<=len;++i)

		g[i]=f[i<<1|1],h[i]=f[i<<1];

	FFT(g,len>>1,v);

	FFT(h,len>>1,v);

	complex og1,og;

	len<<=1;

	og=complex(1,0);

	og1=complex(cos(Pi*2/len),v*sin(Pi*2/len));

	for (R k=0;k<len/2;++k)

	{

		f[k]=og*g[k]+h[k];

		f[k+len/2]=h[k]-og*g[k];

		og=og1*og;

	}

}

如果\(v=1\)，那么就是\(DFT\)，\(v=-1\)就是\(IDFT\)

现在再来看看那个矩阵为什么就是\(A^{-1}\)了

设上面那个矩阵叫\(T\)，设\(A\times T=S\)

那么

\[S_{i,j}=\frac{1}{n}\sum_{k=0}^{n-1}A_{i,k}\times T_{k,j}
\]

\[=\frac{1}{n}\sum_{k=0}^{n-1}(\omega_{n}^i)^k\times (\omega_{n}^{-k})^j
\]

\[=\frac{1}{n}\sum_{k=0}^{n-1}\omega_{n}^{ki}\times \omega_{n}^{-kj}
\]

\[=\frac{1}{n}\sum_{k=0}^{n-1}\omega_{n}^{k(i-j)}
\]

当\(i=j\)时

\[\omega_{n}^0=1
\]

所以

\[S_{i,j}=\frac{\sum_{k=0}^{n-1}1}{n}=1
\]

如果\(i\neq j\)

设\(x=i-j\)

\[S_{i,j}=\frac{1}{n}\sum_{k=0}^{n-1}\omega_{n}^{kx}=\frac{1}{n}\sum_{k=0}^{n-1}(\omega_{n}^x)^k
\]

这不一等比数列求和吗，公比为\(\omega_{n}^x\)，首项为\(1\)

于是

\[\sum_{k=0}^{n-1}(\omega_{n}^x)^k=\frac{1-(\omega_{n}^x)^n}{1-\omega_{n}^x}=\frac{1-\omega_{n}^{xn}}{1-\omega_{n}^x}
\]

显然\(\omega_{n}^{nx}=\omega_{n}^{nx\% n}=\omega_{n}^0=1\)

所以

\[\sum_{k=0}^{n-1}(\omega_{n}^x)^k=0
\]

\[S_{i,j}=0(i\neq j)
\]

所以我们惊奇的发现\(S\)是一个单位矩阵，所以\(T=A^{-1}\)证毕

5.蝴蝶变换

我先咕了，先把板子放上

#include<algorithm>

#include<iostream>

#include<cstring>

#include<cstdio>

#include<cmath>

#define maxn 2000005

#define re register

#define eps 1e-6

struct complex

{

	double r,c;

	complex (double a=0,double b=0) {r=a;c=b;}

}f[maxn],g[maxn],og,og1,t;

complex operator +(complex a,complex b) {return complex(a.r+b.r,a.c+b.c);}

complex operator -(complex a,complex b) {return complex(a.r-b.r,a.c-b.c);}

complex operator *(complex a,complex b) {return complex(a.r*b.r-a.c*b.c,a.r*b.c+a.c*b.r);}

const double Pi=acos(-1);

int n,m,len,rev[maxn];

inline void FFT(complex *f,int v)

{

	for(re int i=0;i<len;i++) if(i<rev[i]) std::swap(f[i],f[rev[i]]);

	for(re int i=2;i<=len;i<<=1)

	{

		int ln=i>>1;

		og1=complex(cos(Pi/ln),v*sin(Pi/ln));

		for(re int l=0;l<len;l+=i)

		{

			og=complex(1,0);

			for(re int x=l;x<l+ln;x++)

			{

				t=og*f[ln+x];

				f[ln+x]=f[x]-t;

				f[x]=f[x]+t;

				og=og*og1;

			}

		}

	}

}

inline int check(double x) {if(x-eps<0&&x+eps>0) return 1;return 0;}

int main()

{

	scanf("%d%d",&n,&m);

	for(re int i=0;i<=n;i++) scanf("%lf",&f[i].r),f[i].c=0;

	for(re int i=0;i<=m;i++) scanf("%lf",&g[i].r),g[i].c=0;

	len=1; while(len<n+m+1) len<<=1;

	for(re int i=1;i<=len;i++) rev[i]=(rev[i>>1]>>1)|((i&1)?len>>1:0);

	FFT(f,1),FFT(g,1);

	for(re int i=0;i<len;i++) f[i]=f[i]*g[i];

	FFT(f,-1);

	for (re int i=0;i<=m+n;++i)

    {

        f[i].r/=len;

        if(check(f[i].r)) f[i].r=0;

    }

	for(re int i=0;i<=m+n;i++) printf("%.0lf ",f[i].r);

	return 0;

}

蝴蝶变换就咕咕咕了，就是背一下板子好了

\(FFT\)尽管功能强大，但是由于做了大量虚数的运算所以经常精度堪忧

这个时候\(NTT\)就出场了

\(NTT\)就是可以取模的\(FFT\)了

\(FFT\)强大的功能取决于单位根的性质，而\(NTT\)在模意义下要做到这一点，就需要原根了

首先原根是个啥

定义如下

对于一个质数\(p=qn+1\)，\(n=2^k\)，存在\(g\)使得\(g^i\)(\(0<=i<=p-1\))是不同的数，就称\(g\)为\(p\)的原根

对于最常见的\(NTT\)模数\(998244353=7\times 17\times 2^{23}+1\)，其原根为\(3\)

来看看单位根的几条性质原根是否满足

\(\omega_{2n}^{2k}=\omega_n^k\)

我们先定义\(n\)次原根分别为\(1,g^q,g^{2q}...g^{(n-1)q}\)

显然\(\omega_{2n}^{2k}=g^{\frac{q}{2}\times 2k}=g^{qk}\)，因为\(p=\frac{q}{2}\times 2n+1\)

非常美妙的是\(\omega_n^k=g^{qk}\)，所以这样的性质原根也有

\(\omega_n^k\times \omega_n^j=\omega_{n}^{k+j}\)

这一条应该这非常显然

\(\omega_n^k=g^{qk},\omega_n^j=g^{qj}\)，于是\(\omega_n^k\times \omega_n^j=g^{qk}\times g^{qj}=g^{q(k+j)}\)

非常美妙的是\(\omega_n^{k+j}=g^{q(k+j)}\)，所以这样的性质原根也有

\(\omega_n^{\frac{n}{2}}\equiv -1(mod\ p)\)

有了这样的性质就可以分治了

因为\(\omega_n^{\frac{n}{2}}\times \omega_n^{\frac{n}{2}}=\omega_{n}^n=\omega_{n}^0=1\)

所以\(\omega_n^{\frac{n}{2}}\equiv 1,-1\)，又因为\(\omega_{n}^0=1\)，\(\omega_n^{\frac{n}{2}}\)不能和它相等，于是只能\(\omega_n^{\frac{n}{2}}\equiv -1\)

之后\(NTT\)的板子基本和\(FFT\)一样真的只是把单位根换成了原根

#include<algorithm>

#include<iostream>

#include<cstring>

#include<cstdio>

#define maxn 3000005

#define re register

#define LL long long

#define max(a,b) ((a)>(b)?(a):(b))

#define min(a,b) ((a)<(b)?(a):(b))

inline int read() {

	char c=getchar();int x=0;while(c<'0'||c>'9') c=getchar();

	while(c>='0'&&c<='9') x=(x<<3)+(x<<1)+c-48,c=getchar();return x;

}

const LL g=3;

const LL mod=998244353;

const LL ig=332748118;

LL a[maxn],b[maxn];

int rev[maxn];

int n,m,len=1;

inline LL quick(LL a,LL b) {LL S=1;while(b) {if(b&1ll) S=S*a%mod;b>>=1ll;a=a*a%mod;}return S;}

inline void NTT(LL *f,int o) {

	for(re int i=0;i<len;i++) if(i<rev[i]) std::swap(f[i],f[rev[i]]);

	for(re int i=2;i<=len;i<<=1) {

		int ln=i>>1;LL og1=quick(o==1?g:ig,(mod-1)/i);

		for(re int l=0;l<len;l+=i) {

			LL og=1,t;

			for(re int x=l;x<l+ln;x++) {

				t=og*f[ln+x]%mod;

				f[ln+x]=(f[x]-t+mod)%mod;

				f[x]=(f[x]+t)%mod;

				og=(og*og1)%mod;

			}

		}

	}

}

int main()

{

	n=read(),m=read();

	for(re int i=0;i<=n;i++) a[i]=read();

	for(re int i=0;i<=m;i++) b[i]=read();

	while(len<=n+m) len<<=1;

	for(re int i=0;i<len;i++) rev[i]=(rev[i>>1]>>1)|((i&1)?len>>1:0);

	NTT(a,1),NTT(b,1);

	for(re int i=0;i<len;i++) a[i]=a[i]*b[i]%mod;

	NTT(a,-1);

	LL inv=quick(len,mod-2);

	for(re int i=0;i<=n+m;i++) printf("%lld ",inv*a[i]%mod);

	return 0;

}