浅谈FFT&NTT
复数及单位根
复数的定义大概就是:\(i^2=-1\),其中\(i\)就是虚数单位。
那么,在复数意义下,对于方程:
\]
就必定有\(n\)个解,这\(n\)个解的分布一定是在复平面上,以圆点为圆心,半径为\(1\)的圆的\(n\)等分点。
由于欧拉公式:
\]
把\(2\pi\)带入:
\]
比较一下这个和上面的方程,设:
\]
那么可以得到上面方程的\(n\)个解分别为:
\]
那么,我们称这\(n\)个解为\(n\)次单位根。
关于单位根,有以下性质:
\]
这些性质的证明都很简单。
点值表达式
考虑到,一个多项式可以看做是一个\(n\)次的函数,如果已知这个函数的\(n+1\)个点,那么就可以确定这个多项式。
任取\(n+1\)个不同的数\(x_i\),知道了多项式的结果\(F(x_i)\),这个称作多项式的点值表达式。
离散傅里叶变换(Discrete Fourier Transform, DFT)
对于一个\(n-1\)次多项式,取\(n\)个数\(w_n^0,w_n^1...w_n^{n-1}\),得到一个点值表达式,称作离散傅里叶变换。
先把这个多项式凑成\(n=2^x\)的形式,高位补\(0\)。
对于\(F(\omega_n^{k})\),显然可以得到:
\]
其中\(A_i\)为系数。
然后对这个进行奇偶分类,可得:
F(\omega_n^k)&=\sum_{i=0}^{n/2-1}(\omega_n^{k})^{2i}\cdot A_{2i}+\sum_{i=0}^{n/2-1}(\omega_n^k)^{2i+1}\cdot A_{2i+1}\\
&=\sum_{i=0}^{n/2-1}(\omega_{n/2}^{k})^i\cdot A_{2i}+\omega_n^k\cdot \sum_{i=0}^{n/2-1}(\omega_{n/2}^k)^{i}\cdot A_{2i+1}
\end{align}
\]
设\(F_0(x)\)为偶数项的系数构成的多项式,\(F_1(x)\)为奇数项,这个显然是一个子问题。
那么:
\]
所以,令\(k\leqslant n/2\),则有:
\]
即:
\\F(\omega_n^{k+n/2})=F_0(\omega_{n/2}^k)-w_n^{k}\cdot F_1(\omega_{n/2}^k)
\]
递归计算即可,复杂度:
\]
离散傅里叶逆变换(Inverse Discrete Fourier Transform, IDFT)
对于离散傅里叶变换,写成矩阵的形式就是:
(\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}
\times
\begin{bmatrix}
A_0\\A_1\\\vdots\\A_{n-1}
\end{bmatrix}
=
\begin{bmatrix}
F(\omega_n^0)\\F(\omega_n^1)\\\vdots\\F(\omega_n^{n-1})
\end{bmatrix}
\]
现在,我们是知道了等号右边的\(F\),要求等号左边的\(A\)。
设上面的系数矩阵为\(s\),考虑下面这个矩阵,设为\(t\)。
(\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}
\]
考虑矩阵\(v=t\times s\):
对于\(v_{i,j}\),根据矩阵乘法规则,它会等于:
\]
若\(i=j\),则:
\]
否则:
\]
注意到:
\]
所以:
\]
然后把这个矩阵写出来:
n&0&\cdots&0\\
0&n&\cdots&0\\
\vdots&\vdots&\ddots&\vdots\\
0&0&\cdots&n
\end{bmatrix}
\]
然后可以发现,这个就是单位矩阵的\(n\)倍,即:
\]
然后考虑第一个矩阵的式子,等式两边同时左乘一个\(t\),可得:
\begin{bmatrix}
A_0\\A_1\\\vdots\\A_{n-1}
\end{bmatrix}
=
\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}
\times
\begin{bmatrix}
F(\omega_n^0)\\F(\omega_n^1)\\\vdots\\F(\omega_n^{n-1})
\end{bmatrix}
\]
所以,\(IDFT\)的时候直接照搬\(DFT\),然后把\(\omega_n^k\)改成\(\omega_n^{-k}\),最后在除个\(n\)就好了。
迭代实现
由于上面的递归实现常数过大,不是很优秀,这里有一种迭代的实现方法。
考虑我们把递归过程改成迭代,那么显然我们需要把顺序重新排列一下,然后每次把相邻的\(2^k\)个数合并就好了。
令\(n=2^m\),考虑第\(i\)次递归的时候,二进制下第\(i\)为\(0\)的放左边,为\(1\)的放右边,那么可以发现,左边的所有数新位置的编号第\(m-i+1\)位都为\(0\),右边的为\(1\),这个可以自己画下图理解下。
那么,设\(rev(x)\)表示把\(x\)的二进制翻转的结果,即第\(i\)位和第\(m-i+1\)位交换。
对于原序列第\(i\)个数,他在新序列的位置就应该是\(rev(i)\)。
代码就比较好写了:
#include<cmath>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
void read(int &x) {
x=0;int f=1;char ch=getchar();
for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-f;
for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';x*=f;
}
void print(int x) {
if(x<0) putchar('-'),x=-x;
if(!x) return ;print(x/10),putchar(x%10+48);
}
void write(int x) {if(!x) putchar('0');else print(x);putchar('\n');}
const int maxn = 4e6+10;
#define lf double
const lf pi = acos(-1);
struct complex {
lf real,imag;
complex () {}
complex (lf _real,lf _imag) {real=_real,imag=_imag;}
complex conj() {return complex(real,-imag);} //共轭复数
complex operator = (const int &rhs) {real=rhs;return *this;}
complex operator + (const complex &rhs) const {return complex(real+rhs.real,imag+rhs.imag);}
complex operator - (const complex &rhs) const {return complex(real-rhs.real,imag-rhs.imag);}
complex operator * (const complex &rhs) const {return complex(real*rhs.real-imag*rhs.imag,imag*rhs.real+real*rhs.imag);}
}; //手写的一个复数类
complex es[maxn],ces[maxn],a[maxn],b[maxn];
int n,m,N,pos[maxn],bit;
void init() {
for(int i=0;i<N;i++) es[i]=complex(cos(2*pi/N*i),sin(2*pi/N*i));
for(int i=0;i<N;i++) ces[i]=es[i].conj(); //预处理单位根
for(int i=1;i<N;i++) pos[i]=pos[i>>1]>>1|((i&1)<<(bit-1)); //pos[x]表示rev(x)
}
void fft(complex *r,complex *w) {
for(int i=0;i<N;i++) if(pos[i]>i) swap(r[i],r[pos[i]]); //调整位置
for(int i=1;i<N;i<<=1)
for(int j=0;j<N;j+=(i<<1))
for(int k=0;k<i;k++) {
complex x=r[j+k],y=w[N/(i<<1)*k]*r[j+k+i]; //迭代实现
r[j+k]=x+y,r[i+j+k]=x-y;
}
}
int main() {
read(n),read(m);
for(int i=0,x;i<=n;i++) read(x),a[i]=x;
for(int i=0,x;i<=m;i++) read(x),b[i]=x;
N=1;while(N<=n+m) N<<=1,bit++;
init();fft(a,es),fft(b,es);
for(int i=0;i<=N;i++) a[i]=a[i]*b[i];fft(a,ces);
for(int i=0;i<=n+m;i++) printf("%d ",(int)(a[i].real/N+0.5));puts(""); //记得答案要除N,这个其实应该写在fft函数里面。。
return 0;
}
这份代码在洛谷的模板P3803 【模板】多项式乘法(FFT)提交可以通过。
快速数论变换(Fast Number-Theoretic Transform,FNT)
这玩意其实一般叫做\(NTT\)。
考虑到上面\(FFT\)的过程用到了单位根的哪些性质:
- \(\omega_n^0,\omega_n^1...\omega_n^{n-1}\)互不相同,这保证了点值表达式可以成立。
- \(\omega_n^2=\omega_{n/2}\),\(\omega_n^{k+n/2}=-\omega_n^k\)。
- \(\omega_n^n=1\),这保证了IDFT的正确性。
对于模数\(p=k\cdot 2^s+1\),且\(p\)为质数,设它的原根为\(g\),那么我们可以令\(\omega_n=g^{(p-1)/n}\)。
由于原根的性质,第一条显然是满足的。
对于第二条:
\]
并且:
\]
也比较显然。
对于第三点,其实就是费马小定理,显然满足,所以我们可以用这个来替代\(\omega_n\),进行数论变换,代码也差不多。
注意,对于质数\(p=k\cdot 2^s+1\),它能处理的数据范围是\(n\leqslant 2^s\)。
模板:题目和上题相同
#include<bits/stdc++.h>
using namespace std;
void read(int &x) {
x=0;int f=1;char ch=getchar();
for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-f;
for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';x*=f;
}
void print(int x) {
if(x<0) putchar('-'),x=-x;
if(!x) return ;print(x/10),putchar(x%10+48);
}
void write(int x) {if(!x) putchar('0');else print(x);putchar('\n');}
const int maxn = 4e6+10;
const int mod = 998244353;
int n,m,N=1,bit,pos[maxn],es[maxn],ces[maxn],a[maxn],b[maxn];
int qpow(int aa,int x) {
int res=1;
for(;x;x>>=1,aa=1ll*aa*aa%mod) if(x&1) res=1ll*res*aa%mod;
return res;
}
void ntt(int *r,int f) {
for(int i=0;i<N;i++) if(pos[i]>i) swap(r[i],r[pos[i]]);
for(int i=1;i<N;i<<=1) {
int wn=qpow(f==1?3:qpow(3,mod-2),(mod-1)/(i<<1));
for(int j=0,w=1;j<N;j+=(i<<1),w=1)
for(int k=0;k<i;k++,w=1ll*w*wn%mod) {
int x=r[j+k],y=1ll*w*r[i+j+k]%mod;
r[j+k]=(x+y)%mod,r[i+j+k]=(x-y)%mod;
}
}
}
int main() {
read(n),read(m);
for(int i=0;i<=n;i++) read(a[i]);
for(int i=0;i<=m;i++) read(b[i]);
while(N<=n+m) N<<=1,bit++;
for(int i=0;i<N;i++) pos[i]=pos[i>>1]>>1|((i&1)<<(bit-1));
ntt(a,1),ntt(b,1);
for(int i=0;i<=N;i++) a[i]=1ll*a[i]*b[i]%mod;
ntt(a,-1);int inv=qpow(N,mod-2);
for(int i=0;i<=n+m;i++) printf("%d ",((1ll*a[i]*inv%mod)+mod)%mod);puts("");
return 0;
}
任意模数NTT(MTT)
设现在要算的是多项式\(A\times B\),模数可能不满足\(p=k\cdot 2^s+1\),甚至可以不是个质数。
如果直接\(FFT\)的话,显然会爆精度,现在考虑如何优化精度。
设\(r=\lceil\sqrt{p}\rceil\),那么对于多项式的每一项,设系数为\(s\),显然可以写成\(s=a\cdot r+b\)的形式。.
那么对于\(s\cdot t\),设\(s=a\cdot r+b,t=c\cdot r+d\),那么\(s\cdot t=ac\cdot r^2+(ad+bc)\cdot r+bd\)。
所以,可以把一个多项式拆成两个,分别做\(FFT\),这样精度一般是不会爆的。
然后正反一共做\(8\)遍\(FFT\)就好了。
好像有只需要做4遍FFT的方法,以后填坑。。
代码:题目出自【模板】任意模数NTT
#include<cmath>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
void read(int &x) {
x=0;int f=1;char ch=getchar();
for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-f;
for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';x*=f;
}
void print(int x) {
if(x<0) putchar('-'),x=-x;
if(!x) return ;print(x/10),putchar(x%10+48);
}
void write(int x) {if(!x) putchar('0');else print(x);putchar('\n');}
#define lf double
const int maxn = 4e5+10;
typedef long long ll;
struct complex {
lf r,i;
complex () {}
complex (lf _r,lf _i) {r=_r,i=_i;}
complex conj() {return complex(r,-i);}
complex operator = (const int &rhs) {r=rhs;return *this;}
complex operator - (const complex &rhs) const {return complex(r-rhs.r,i-rhs.i);}
complex operator + (const complex &rhs) const {return complex(r+rhs.r,i+rhs.i);}
complex operator * (const complex &rhs) const {return complex(r*rhs.r-i*rhs.i,r*rhs.i+i*rhs.r);}
}w1[maxn],w2[maxn],a[maxn],b[maxn],c[maxn],d[maxn];
int N,bit,n,m,s[maxn],t[maxn],mod,p,ans[maxn],pos[maxn];
const lf pi = acos(-1);
void init() {
N=1,bit=0;while(N<=n+m) N<<=1,bit++;
for(int i=0;i<N;i++) pos[i]=pos[i>>1]>>1|((i&1)<<(bit-1));
w1[0]=1;for(int i=1;i<N;i++) w1[i]=complex(cos(pi*2*i/N),sin(pi*2*i/N));
for(int i=0;i<N;i++) w2[i]=w1[i].conj();
}
void fft(complex *r,complex *w,int f) {
for(int i=0;i<N;i++) if(pos[i]>i) swap(r[i],r[pos[i]]);
for(int i=1;i<N;i<<=1)
for(int j=0;j<N;j+=(i<<1))
for(int k=0;k<i;k++) {
complex x=r[j+k],y=w[N/(i<<1)*k]*r[i+j+k];
r[j+k]=x+y,r[i+j+k]=x-y;
}
if(f==-1) for(int i=0;i<N;i++) r[i].r/=N,r[i].i=0;
}
void mul(int *A,int *B,int *C) {
for(int i=0;i<=n;i++) a[i]=A[i]/p,b[i]=A[i]%p;
for(int i=0;i<=m;i++) c[i]=B[i]/p,d[i]=B[i]%p;
init();
fft(a,w1,1),fft(b,w1,1),fft(c,w1,1),fft(d,w1,1);
for(int i=0;i<N;i++) {
complex tmpa=a[i],tmpb=b[i],tmpc=c[i],tmpd=d[i];
a[i]=tmpa*tmpc,b[i]=tmpa*tmpd+tmpb*tmpc,c[i]=tmpb*tmpd;
}
fft(a,w2,-1),fft(b,w2,-1),fft(c,w2,-1);
for(int i=0;i<N;i++) {
ll tmpa=ll(a[i].r+0.5),tmpb=ll(b[i].r+0.5),tmpc=ll(c[i].r+0.5);
C[i]=(tmpa%mod*p%mod*p%mod+tmpb%mod*p%mod-mod+tmpc)%mod;
}
}
int main() {
read(n),read(m),read(mod);p=sqrt(mod)+1;
for(int i=0;i<=n;i++) read(s[i]),s[i]%=mod;
for(int i=0;i<=m;i++) read(t[i]),t[i]%=mod;
mul(s,t,ans);
for(int i=0;i<=n+m;i++) printf("%d ",(ans[i]+mod)%mod);puts("");
return 0;
}
浅谈FFT&NTT的更多相关文章
- 浅谈FFT、NTT和MTT
前言 \(\text{FFT}\)(快速傅里叶变换)是 \(O(n\log n)\) 解决多项式乘法的一个算法,\(\text{NTT}\)(快速数论变换)则是在模域下的,而 \(\text{MTT} ...
- 浅谈FFT(快速傅里叶变换)
前言 啊摸鱼真爽哈哈哈哈哈哈 这个假期努力多更几篇( 理解本算法需对一些< 常 用 >数学概念比较清楚,如复数.虚数.三角函数等(不会的自己查去(其实就是懒得写了(¬︿̫̿¬☆) 整理了一 ...
- 浅谈FFT(快速傅里叶变换)
本文主要简单写写自己在算法竞赛中学习FFT的经历以及一些自己的理解和想法. FFT的介绍以及入门就不赘述了,网上有许多相关的资料,入门的话推荐这篇博客:FFT(最详细最通俗的入门手册),里面介绍得很详 ...
- 浅谈FFT(快速博立叶变换)&学习笔记
0XFF---FFT是啥? FFT是一种DFT的高效算法,称为快速傅立叶变换(fast Fourier transform),它根据离散傅氏变换的奇.偶.虚.实等 特性,对离散傅立叶变换的算法进行改进 ...
- 浅谈范德蒙德(Vandermonde)方阵的逆矩阵的求法以及快速傅里叶变换(FFT)中IDFT的原理
浅谈范德蒙德(Vandermonde)方阵的逆矩阵与拉格朗日(Lagrange)插值的关系以及快速傅里叶变换(FFT)中IDFT的原理 标签: 行列式 矩阵 线性代数 FFT 拉格朗日插值 只要稍微看 ...
- FFT/NTT复习笔记&多项式&生成函数学习笔记Ⅰ
众所周知,tzc 在 2019 年(12 月 31 日)就第一次开始接触多项式相关算法,可到 2021 年(1 月 1 日)才开始写这篇 blog. 感觉自己开了个大坑( 多项式 多项式乘法 好吧这个 ...
- 浅谈 Fragment 生命周期
版权声明:本文为博主原创文章,未经博主允许不得转载. 微博:厉圣杰 源码:AndroidDemo/Fragment 文中如有纰漏,欢迎大家留言指出. Fragment 是在 Android 3.0 中 ...
- 浅谈 LayoutInflater
浅谈 LayoutInflater 版权声明:本文为博主原创文章,未经博主允许不得转载. 微博:厉圣杰 源码:AndroidDemo/View 文中如有纰漏,欢迎大家留言指出. 在 Android 的 ...
- 浅谈Java的throw与throws
转载:http://blog.csdn.net/luoweifu/article/details/10721543 我进行了一些加工,不是本人原创但比原博主要更完善~ 浅谈Java异常 以前虽然知道一 ...
随机推荐
- WPF 如何自定义一个弹框
------------吾亦无他,唯手熟尔,谦卑若愚,好学若饥------------- 简述: 手工以原生Grid的方式,自定义了一个仿弹窗效果,优点可以自定义,缺点需要自己实现以及维护整个弹窗的效 ...
- Struts 2(五):输入校验 & 校验框架
第一节 Struts2输入校验 1.1 输入校验的重要性 输入校验分为客户端校验和服务器端校验.客户端校验用来过滤用户的错误操作,一般使用JavaScript代码实现.服务器端校验用来防止非法用户的恶 ...
- SQL Server 2008 R2 链接 Oracle 10g
首先sqlserver 链接oracle可以通过两个访问接口: “MSDAORA” 和“OraOLEDB.Oracle” 1.“MSDAORA”访问接口是由Microsoft OLE DB Provi ...
- 提取验证码到winform上webbroswer和axwebbroswer
在网上只有webbroswer的代码,所以自己又修改了修改改成axwebbroswer的 public static class yanZhengMaHelp { //webbrowser验证码 pu ...
- Linux 防火墙设置(转)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 3 ...
- JAVA学习笔记--正则表达式
正则表达式是一种强大而灵活的文本处理工具.使用正则表达式,可以让我们以编程的方式构造复杂的文本,并对输入的字符串进行搜索. 一.基础正则表达式语法(表格来自J2SE6_API) 字符 x 字符 x \ ...
- spring JDBC 事务管理
spring JDBC 事务管理 一.Spring 中的JDBC Spring中封装了JDBC的ORM框架,可以用它来操作数据,不需要再使用外部的OEM框架(MyBatis),一些小的项目用它. 步骤 ...
- 亚马逊6月18日发布惊世之作 或为3D智能手机
亚马逊将在 6 月 18 日举行一个产品发布会. 其内容可能是关于传闻已久的亚马逊智能手机.该公司在 YouTube 上公布了一段炫耀这款设备的视频.这段视频展示了很多人在这款产品前摇头晃脑,并且表现 ...
- Beta冲刺第二周王者荣耀交流协会第三次会议
1.例会照片: 成员王超,高远博,冉华,王磊,王玉玲,任思佳,袁玥全部到齐 master:袁玥 2.时间跨度: 2017年11月19日 17:00 — 17:11,总计11分钟. 3.地 点: 一食堂 ...
- lintcode-425-电话号码的字母组合
425-电话号码的字母组合 Given a digit string excluded 01, return all possible letter combinations that the num ...