预先知识：无
我觉得我们可以从NTT/FFT讲起？
两个其实本质相同，都是求 多项式乘积 的算法
\((x,y)\)指复数，我们可以不用管它
首先我们构造单位根\(\omega_n\)=\((cos(2\pi/n),sin(2\pi/n))\)
而\((\omega _n)^i=(cos(2\pi/n\cdot i),sin(2\pi/n\cdot i))\)
伟大的数学家们告诉我们\((\omega_n)^n=1\)
也就是说\(\omega_n\)实际上是一个\(n\)元循环的根
\[ \ \]
首先我们对于一个模数\(P\)(通常是质数)，构造单位根\(g\)，使得满足\(\{k\in N^+|g^k \equiv 1 (\mod P)\}\)的最小的\(k\)是\(P-1\)
伟大的数学家们告诉我们，这个\(g\)是\(P\)的一个原根(？)
也就是说,\(g^k\)在模\(P\)意义下呈现\(P-1\) 次一循环
Tips:构造模意义下的单位根就以为这我们求出的系数都是对于\(P\)取模过的
通常我们\(P\)取\(998244353\)，\(2^{23}|(P-1)\)，它的一个原根是3
\[ \ \]
一个多项式\(f(x)=\sum_0^{n-1} a_i x^i\)
可以表示成n个点\((x_i,y_i)\)，其中\(x_i \ne x_j(i\ne j)\)
也就是说我们可以通过消元和暴力计算完成\(O(n^2)/O(n^3)\)的点值转化
伟大的数学家们又告诉我们，这样的点值式一定可以完成唯一的反解
点值式有几个简单的性质
\(\{(x_i,y_i)\} + \{(x_i,z_i)\}=\{(x_i,y_i + z_i)\}\)
\(\{(x_i,y_i)\} \cdot \{(x_i,z_i)\}=\{(x_i,y_i \cdot z_i)\}\)
这个东西想必不需要我多说了
\[ \ \]
对于单位根，无论是什么单位根，我们可以利用分治的方式快速完成点值式与多项式之间的转化，利用这一点，我们可以得到\(FFT/NTT\)的主要流程
多项式\(\Longrightarrow\)点值式\(\Longrightarrow\)点值式相乘\(\Longrightarrow\)多项式
可以看到，这个东西是\(nlogn\)
接下来我们考虑如何将多项式转化为点值式
我们构造特殊的\(x_i=\omega_n^i(g^i)\)（哪一个都可以）
单位根有一个明显的性质帮助我们解题$(\omega_n)^i=(\omega _{n/2})^{i/2} $(折半引理)
成立条件\((2|i,2|n)\)
对于\(g\)我们可以认为\(\omega _n\)=\(g^{(P-1)/n}\)
要求\(f(x_1)=\sum a_i(\omega_n)^i\)
我们可以先求出
\(g(x_1)=a_0\omega_{n/2}^0+a_2\omega_{n/2}^2..\)
\(h(x_1)= a_1\omega_{n/2}^0+a_3\omega_{n/2}^2..\)
其实就是分治子问题
然后我们通过合并得到\(f(x)\)
\(g(x_1) \Longleftrightarrow a_0\omega_n^0+a_2\omega_n^2..\)
\(h(x_1) \Longleftrightarrow a_1\omega_n^0+a_3\omega_n^2..\)
我们要求的是$f(x_1)=a_0\omega_n^0+a_2\omega_n^2.. + a_1\omega_n^1+a_3\omega_n^3.. $
\(f(x_1)=g(x_1)+x^1h(x_1)\)
啊！
还有\(f(x_i)=g(x_i)+x^i h(x_i)\)
这个过程看似顺畅，实际上我们必须考虑最重要的问题\(\omega_n^i\rightarrow \omega _{n/2}^{i/2}\)真的能求吗？
我们要保证每一次分治时\(n\)都是\(2\)的倍数，对于所有数据适用，所以\(n\)必须转化为\(2^k\)
int N=1;
while(N<=n+m) N<<=1;这样我们就能好好写分治了
tips:回到之前\(g_n\)的求法，\(n|(P-1)\)是一个大前提，所以我们找到的所有原根都是\(2^k\)倍数
\[ \ \]
关于它的逆运算：伟大的数学家们告诉我们直接将原根取成倒数做一次变换，最后全部除以\(n\)即可
(复数的倒数是共轭复数\((a,b)*(c,d)=(1,0)\)，原根的倒数是模逆元)
但是由于过(我)于(太)冗(菜)长(了)，不予展开
另有\((\omega_n)^{-i}=(cos(2\pi/n\cdot i),-sin(2\pi/n\cdot i))\)(诱导公式?)
Tips: 由于整个过程的单位根对于\(n\)取模，所以求得的其实是\(f(x^{i\mod n})\)
然后我们得到一份优美的代码(FFT)
(Complex是C++库自带的复数，他们的运算我们暂时不管,M_PI是C++自带\(\pi\)常量)
void FFT(int n,Complex *a,int f) {
if(n==1) return;
Complex tmp[N];
int m=n/2;
rep(i,0,m-1) tmp[i]=a[i<<1],tmp[i+m]=a[i<<1|1]; // 按照奇偶分类
memcpy(a,tmp,sizeof(T)*n);
DFT(m,a,f),DFT(m,a+m,f); // 分两半，算g(x),h(x)
Complex w(cos(2*M_PI/n),f*sin(2*M_PI/n)),e(1,0); // w=x^1,e=x^i
rep(i,0,m-1) {
tmp[i]=a[i]+e*a[i+m]; // f(x_i)=g(x_i)-e*h(x_i)
e=e*w;
}
rep(i,m,n-1) {
tmp[i]=a[i-m]+e*a[i];
e=e*w;
}
memcpy(a,tmp,sizeof(T)*n);
}由于\((\omega_n)^{\frac{n}{2}}=-1\)(额自己理解一下，或者带一下\(\omega\)的式子)
所以还可以简化为
Complex w(cos(2*M_PI/n),f*sin(2*M_PI/n)),e(1,0);
rep(i,0,m-1) {
tmp[i]=a[i]+e*a[i+m];
tmp[i+m]=a[i]-e*a[i+m];
e=e*w;
}由于用了double，最后输出要取整
但是这份代码跑得依然巨慢，简直连1e6都做不了
我们加一点优化，取代递归的分治过程
可以看到，分治时我们按照\(i \mod 2\)分成两组，然后继续分
这个过程中，实际上我们就是将\(i\)的二进制位前后翻转
所以我们可以暴力处理出\(i\)分治底层的位置
rep(i,0,n-1) {
int x=i,s=0;
for(int j=1;(j<<c)<=n;++j) {
s=(s<<1)|(x&1);
x>>=1;
} // s就是最终位置
}当然也是有\(O(n)\)处理方法的
int N=1,c=-1;
while(N<=n+m) N<<=1,c++;
rep(i,1,N-1) rev[i]=(rev[i>>1]>>1)|((i&1)<<c);(建议自己模拟一下)
接下来我们枚举分治长度\(i\)，枚举合并区间的最短点\(l\)，枚举合并的位置\(j\)
合并方法和上文一样，但是由于这里没有另外开一个\(temp\)数组，所以合并时要注意一下顺序
for(int i=2;i<=n;++i) {
int m=i/2;
Complex w(cos(2*M_PI/n),f*sin(2*M_PI/n));
for(int l=0;l<n;l+=i) {
Complex e(1,0);
for(int j=l;j<l+i;++j,e=e*w) {
Complex t=a[j+m]*e; // a'[j]=a[j]+e*a[j+m]
// a'[j+i]=a[j]-e*a[j+m]
a[j+m]=a[j]-t;
a[j]=a[j]+t;
}
}
}事实上我们还有更快的写法，就是将\((\omega_n)^i\)预处理出来，就避免了多次计算，这个代码留给读者自己写
当然如果自己写复数会更快
// Complex
struct Cp{
double x,y;
Cp(){}
Cp(double _x,double _y){ x=_x,y=_y; }
Cp operator + (const Cp t) { return Cp(x+t.x,y+t.y); }
Cp operator - (const Cp t) { return Cp(x-t.x,y-t.y); }
Cp operator * (const Cp t) { return Cp(x*t.x-y*t.y,x*t.y+y*t.x); }
};这个运算可以背一下...
\[ \ \]
顺便提供一份我平时的NTT模板(希望没有敲错)
const int N=1<<18|5,P=998244353;
ll a[N],b[N],w[N];
int rev[N];
void NTT(int n,ll *a,int f){
rep(i,0,n-1)if(i<rev[i]) swap(a[i],a[rev[i]]);
for(int i=1;i<n;i<<=1) {
int len=n/i/2;
for(int l=0;l<n;l+=i*2) {
for(int j=l;j<l+i;++j) {
ll t=a[j+i]*w[len*(j-l)]%P;
a[j+i]=(a[j]-t)%P;
a[j]=(a[j]+t)%P;
}
}
}
if(f==-1) {
ll base=qpow(n,P-2);
rep(i,0,n-1) a[i]=a[i]*base%P;
}
}
int main(){
int R=1,c=-1;
while(R<=n)R<<=1,c++;
rep(i,1,R) rev[i]=(rev[i>>1]>>1)|((i&1)<<c);
w[0]=1,w[1]=qpow(3,(P-1)/R);
rep(i,1,R-1)w[i]=w[i-1]*w[1]%P;
NTT(R,a,1),NTT(R,b,1);
w[0]=1,w[1]=qpow((P+1)/3,(P-1)/R);
rep(i,1,R-1)w[i]=w[i-1]*w[1]%P;
rep(i,0,R-1)a[i]=a[i]*b[i]%P;
NTT(R,a,-1);
}练习建议：
1.高精度乘法
然后去学下面的拓展1，2，3
\[ \ \]
\[ \ \]
\[ \ \]
常用于处理n元计数背包的快速合并
我们可以用NTT\(nlogn\)合并两个大小为\(n\)的背包
分治时，每次合并两个分治子问题，总共的时间就是\(\sum size\log n\)
每个背包的\(size\)会被计算\(\log n\)次，所以总共复杂度是\(n \log ^2 n\)
\[ \ \]
对于形如\(dp[i]=\sum_0^{i-1}dp[j]g[i-j]\)的\(dp\)转移(就是dp转移与差值有关)
我们用NTT/FFT对于每个\((l,mid)\)向\((mid+1,r)\)的转移，总复杂度为\(n\log^2 n\)
算法流程
void Solve(int l,int r){
if(l==r) return;
int mid=(l+r)>>1;
Solve(l,mid);
(l,mid)->(mid+1,r);
Solve(mid+1,r);
}\[ \ \]
就是模数比较奇怪，不能直接算，我们要先算出准确值再取模，但是double算绝对爆炸...
通常有一种比较假但是很好理解：取几个互质的模数分别做一次，然后中国剩余定理合并（贼慢）
正解：拆系数FFT
将系数\(a_i\)分成\(A_i\cdot S+C_i\)
\(b_i\):\(B_i\cdot S+D_i\)
(S是一个常数)
转化后系数值域变小，double精度吃得消
要求出\(A_iB_jS^2+(C_iB_j+A_iD_j)S+C_iD_j\)
利用虚数的一些性质，有些东西我们可以一起算
构造
\(f(x)=\sum (A_i,C_i)x^i\)
\(g(x)=\sum(B_i,D_i)x^i\)
\(f(x)g(x)=\sum (A_iB_i-C_iD_i, A_iD_i+B_iC_i)\)
(其实已经求出一半了)
\(h(x)=\sum B_ix^i\)
\(f(x)h(x)=\sum (A_iB_i,C_iB_i)x^i\)
取一部分即可
最终一共有5次FFT
Tips:负数取整一定要注意，因为是向0取整，而不是向下取整
\[ \ \]
(如果是NTT，必须满足\(n|(P-1)\))
设\(\omega _n\)=t
看到我们要求的\(f(x^k)=\sum a_i\cdot t^{i k}\)
\(i\cdot k=\cfrac{i^2+k^2-(i-k)^2}{2}\)
我们可以对于每一个\(a_i\)计算其对于每个\(f(x^k)\)的贡献(Bluestein’s Algorithm)
具体过程：
构造\(g(x)=\sum a_it^{i^2}x^i,h(x)=t^{-i^2}x^i\)
将两个式子相乘，得到了\(\cfrac{f(x^{2k})}{t^{k^2}}\)
最后再乱处理一下即可
上文我们提到，FFT/NTT得到的结果是\(f(x^{i\mod n})\)
也就是说系数同样存在循环关系，我们可以利用\(n\)元卷积做到指定大小的循环卷积，可以处理一些特定问题
\[ \ \]
\[ \ \]
(如：两次FFT做卷积，4次FFT做MTT。。。)
原文：https://www.cnblogs.com/chasedeath/p/12070229.html