最近重新学了下卷积,简单总结一下,不涉及细节内容:

1、FFT

朴素求法:$Coefficient-O(n^2)-CoefficientResult$

FFT:$Coefficient-O(nlogn)-Dot-O(n)-DotResult-O(nlogn)-CoefficientResult$

其中系数到点值的转化称为$DFT(离散傅里叶变换)$,而点值到系数的转为称为$IDFT(傅里叶逆变换)$

原本朴素的直接带入$n$个值的$DFT$和直接使用拉格朗日插值公式的$IDFT$的复杂度仍为$O(n^2)$

但$FFT$通过带入特定的值:单位根,使得两者都能迭代/分治得解决,将复杂度降到了$O(nlogn)$

优化的技巧和注意事项:

1、预处理$w[i]$

2、求出最终数组从后往前迭代省去递归常数

3、数组长度要先扩成2的倍数用于分治

模板:

#include <bits/stdc++.h>

using namespace std;
#define X first
#define Y second
#define pb push_back
typedef double db;
typedef long long ll;
typedef pair<int,int> P;
const int MAXN=3e6+;
struct Complex
{
db x,y;
Complex(db a=,db b=){x=a;y=b;}
Complex operator + (const Complex& rhs)
{return Complex(x+rhs.x,y+rhs.y);}
Complex operator - (const Complex& rhs)
{return Complex(x-rhs.x,y-rhs.y);}
Complex operator * (const Complex& rhs)
{return Complex(x*rhs.x-y*rhs.y,x*rhs.y+y*rhs.x);}
}a[MAXN],b[MAXN];
int n,m,lmt=,dgt,par[MAXN]; void FFT(Complex *a,int flag)
{
for(int i=;i<lmt;i++)
if(i<par[i]) swap(a[i],a[par[i]]); for(int len=;len<lmt;len<<=)
{
Complex unit(cos(M_PI/len),flag*sin(M_PI/len));
for(int st=;st<lmt;st+=(len<<))
{
Complex w(,);
for(int k=st;k<st+len;k++,w=w*unit)
{
Complex A=a[k],B=w*a[k+len];
a[k]=A+B;a[k+len]=A-B;
}
}
}
if(flag==-)
for(int i=;i<=n+m;i++)
a[i].x=floor(a[i].x/lmt+0.5);
} int main()
{
scanf("%d%d",&n,&m);
for(int i=;i<=n;i++) scanf("%lf",&a[i].x);
for(int i=;i<=m;i++) scanf("%lf",&b[i].x);
while(lmt<=n+m) lmt<<=,dgt++;
for(int i=;i<lmt;i++)
par[i]=(par[i>>]>>)|((i&)<<(dgt-)); FFT(a,);FFT(b,);
for(int i=;i<lmt;i++)
a[i]=a[i]*b[i];
FFT(a,-);
for(int i=;i<=n+m;i++)
printf("%d ",(int)a[i].x);
return ;
}

FFT

2、NTT

单位根由于涉及了复数的运算,导致对精度要求高时会出错

而$NTT$就能使得整个$FFT$都能在模意义下计算,从而满足精度要求

考虑$FFT$引入单位根$w_n^k$是为了其什么性质来分治计算:

1、$w_n^k$互不相同,保证点值表示的合法

2、$w_{t*n}^{t*k}=w_n^k$且$w_n^{k+2/n}=-w_n^k$,使得计算可分治

3、$\sum_{i=0}^{n-1} {w_n^k}^i=n*[k==0]$,保证逆矩阵构造的正确性

在模意义下引入质数$p=kn+1$,其原根$g$满足$g_t(t\in [0,p-1])$互不相同

这样令$p$的$k$次单位根为$g^{\frac{p-1}{k}}$,易证上述$w_n^k$的性质其在模意义下均满足

接下来考虑该怎样选择质数$p$

为了能够分治时允许$k$每次乘2,$p-1$的质因数分解中要有很多的2

令$p=r*2^k+1$,其能处理的数据规模为$[0,2^k]$,常用质数有:传送门

这样,我们就在模意义下利用原根的性质找到了可做$FFT$的“单位根”

由于没有了复数运算,$NTT$比$FFT$的常数也小了很多,一般是更好的选择

模板:

#include <bits/stdc++.h>

using namespace std;
#define X first
#define Y second
#define pb push_back
typedef double db;
typedef long long ll;
typedef pair<int,int> P;
const int MAXN=4e6+,MOD=;
ll n,m,a[MAXN],b[MAXN],dgt,lmt=,par[MAXN]; ll quick_pow(ll a,ll b)
{
ll ret=;
for(;b;b>>=,a=a*a%MOD)
if(b&) ret=ret*a%MOD;
return ret;
}
void FFT(ll *a,int flag)
{
for(int i=;i<lmt;i++)
if(i<par[i]) swap(a[i],a[par[i]]);
for(int len=;len<lmt;len<<=)
{
ll unit=quick_pow(,(MOD-)/(len<<));
if(flag==-) unit=quick_pow(unit,MOD-);
for(int st=;st<lmt;st+=(len<<))
{
ll w=;
for(int k=st;k<st+len;k++,w=w*unit%MOD)
{
ll A=a[k],B=w*a[k+len]%MOD;
a[k]=(A+B)%MOD;a[k+len]=(A-B+MOD)%MOD;
}
}
}
} int main()
{
scanf("%lld%lld",&n,&m);
for(int i=;i<=n;i++) scanf("%lld",&a[i]);
for(int i=;i<=m;i++) scanf("%lld",&b[i]);
while(lmt<=n+m) lmt<<=,dgt++;
for(int i=;i<lmt;i++)
par[i]=(par[i>>]>>)|((i&)<<(dgt-)); FFT(a,);FFT(b,);
for(int i=;i<lmt;i++)
(a[i]*=b[i])%=MOD;
FFT(a,-);
ll inv=quick_pow(lmt,MOD-);
for(int i=;i<=n+m;i++)
printf("%lld ",a[i]*inv%MOD);
return ;
}

NTT

3、MTT

如果答案需要取模且模数非质数该如何处理呢?

常见背景为:多项式长度$1e5$,模数$1e9$非质数,此时$FFT$爆$longlong$,没法用$NTT$

(1)三模数$NTT$

根据上方的数据限制,可发现最终答案最多为$1e23$

这样就能用多个乘积大于$1e23$的模数分别做$NTT$最后再用$CRT$合并答案即可

一般常用:469762049,998244353,1004535809

可如果直接用$CRT$合并会发现模数爆$longlong$还是不好处理

此时就可以先合并前两个式子,得到

$res=k(mod(p_1*p_2)),res=a_3(mod(p_3))$

这样设$res=p_1*p_2*c+k$再带入二式就能得到$c=(a_3-k)*(p_1*p_2)^{-1}(mod(p_3))$

这样类似$exCRT$的分步处理就避开了对$p_1*p_2*p_3$的取模

但这样要进行9次$DFT/IDFT$,常数巨大无比

模板:

#include <bits/stdc++.h>

using namespace std;
#define X first
#define Y second
#define pb push_back
typedef double db;
typedef long long ll;
typedef pair<int,int> P;
const int MAXN=4e5+;
ll p[]={,,};
int n,m,MOD,F[MAXN],G[MAXN],dgt,lmt=;
ll a[][MAXN],b[MAXN],res[MAXN],par[MAXN]; ll quickpow(ll a,ll b,ll MOD)
{
a%=MOD;ll ret=;
for(;b;b>>=,a=a*a%MOD)
if(b&) ret=ret*a%MOD;
return ret;
}
ll mul(ll a,ll b,ll MOD)
{
a=(a%MOD+MOD)%MOD;
b=(b%MOD+MOD)%MOD;ll ret=;
for(;b;b>>=,a=(a+a)%MOD)
if(b&) (ret+=a)%=MOD;
return ret;
}
ll inv(ll a,ll MOD)
{return quickpow(a,MOD-,MOD);}
void FFT(ll *a,int flag,ll MOD)
{
for(int i=;i<lmt;i++)
if(i<par[i]) swap(a[i],a[par[i]]);
for(int len=;len<lmt;len<<=)
{
ll unit=quickpow(,(MOD-)/(len<<),MOD);
if(flag==-) unit=inv(unit,MOD);
for(int st=;st<lmt;st+=(len<<))
{
ll w=;
for(int k=st;k<st+len;k++,w=w*unit%MOD)
{
ll A=a[k],B=w*a[k+len]%MOD;
a[k]=(A+B)%MOD;a[k+len]=(A-B+MOD)%MOD;
}
}
}
if(flag==-)
{
ll INV=inv(lmt,MOD);
for(int i=;i<lmt;i++)
a[i]=a[i]*INV%MOD;
}
}
void solve(ll *a,ll *b,ll MOD)
{
for(int i=;i<=n;i++) a[i]=F[i];
for(int i=;i<=m;i++) b[i]=G[i];
for(int i=m+;i<lmt;i++) b[i]=;
FFT(a,,MOD);FFT(b,,MOD);
for(int i=;i<lmt;i++) a[i]=a[i]*b[i]%MOD;
FFT(a,-,MOD);
} int main()
{
scanf("%d%d%d",&n,&m,&MOD);
for(int i=;i<=n;i++) scanf("%d",&F[i]);
for(int i=;i<=m;i++) scanf("%d",&G[i]);
while(lmt<=n+m) lmt<<=,dgt++;
for(int i=;i<lmt;i++) par[i]=(par[i>>]>>)|((i&)<<(dgt-)); for(int i=;i<;i++) solve(a[i],b,p[i]);
for(int i=;i<=n+m;i++)
{
ll M=p[]*p[];
ll A=(mul(a[][i]*p[],inv(p[],p[]),M)+
mul(a[][i]*p[],inv(p[],p[]),M))%M;
ll K=mul(a[][i]-A,inv(M,p[]),p[]);
res[i]=(mul(K,M,MOD)+A%MOD)%MOD;
}
for(int i=;i<=n+m;i++)
printf("%lld ",res[i]);
return ;
}

三模数NTT

(2)拆系数$FFT$

不能用$FFT$仅仅因为最后答案会爆$longlong$,那么可以将原数拆分后分别计算

$A_i=a_i* \sqrt{P}+b_i,B_i=c_i* \sqrt{P}+d_i$

此时$A*B=P*(a*c)+\sqrt{P}*(a*d+b*c)+(b*d)$,每部分最大值为$1e14$,分别$DFT/IDFT$

这样要做7次$DFT/IDFT$,效率未显著提升

$myy$在论文里提到过对FFT的优化:

设$P_j=A_j+i*B_j,Q_j=A_j-i*B_j$,使得$DFT$前虚部不再为空

可推出$DFT$后的$DP,DQ$数组如下结论:

$DP_k=\sum_{j=0}^{lmt-1} (A_j+i*B_j)*w_{lmt}^{j*k},DQ_k=conj(DP_{lmt-k})$

这样就能用1次对$P$的$DFT$算出$P,Q,A,B$的$DFT$,从而将上面的4次$DFT$化为2次

由于$IDFT$就能看成$DFT$的逆过程

因此可以合并算出$IDFT(DFT[a]*DFT[c]+i*DFT[b]*DFT[d])$,从而将$IDFT$也化为2次

这样的常数经测试是三模数$NTT$的1/7左右

模板:

#include <bits/stdc++.h>

using namespace std;
#define X first
#define Y second
#define pb push_back
typedef double db;
typedef long long ll;
typedef pair<int,int> P;
const int MAXN=1e6+;
struct Complex
{
db x,y;
Complex(db a=,db b=){x=a;y=b;}
Complex operator +(const Complex& rhs)
{return Complex(x+rhs.x,y+rhs.y);}
Complex operator -(const Complex& rhs)
{return Complex(x-rhs.x,y-rhs.y);}
Complex operator *(const Complex& rhs)
{return Complex(x*rhs.x-y*rhs.y,x*rhs.y+y*rhs.x);}
}a[MAXN],b[MAXN],w[MAXN],t1[MAXN],t2[MAXN],t3[MAXN];
int n,m,MOD,lmt=,dgt,par[MAXN];ll x,res[MAXN]; void FFT(Complex *a,int flag)
{
for(int i=;i<lmt;i++)
if(i<par[i]) swap(a[i],a[par[i]]);
for(int len=;len<lmt;len<<=)
for(int st=;st<lmt;st+=(len<<))
{
int cur=;
for(int k=st;k<st+len;k++)
{
Complex A=a[k],B=w[cur]*a[k+len];
a[k]=A+B;a[k+len]=A-B;
//预处理的写法
cur=(cur+flag*lmt/(len<<)+lmt)&(lmt-);
}
}
if(flag==-)
for(int i=;i<lmt;i++)
a[i].x=floor(a[i].x/lmt+0.5);
}
void solve()
{
FFT(a,);FFT(b,);
for(int i=;i<lmt;i++)
{
Complex d1,d2,d3,d4;
int j=(lmt-i)&(lmt-);
d1=(a[i]+Complex(a[j].x,-a[j].y))*Complex(0.5,);
d2=(a[i]-Complex(a[j].x,-a[j].y))*Complex(,-0.5);
d3=(b[i]+Complex(b[j].x,-b[j].y))*Complex(0.5,);
d4=(b[i]-Complex(b[j].x,-b[j].y))*Complex(,-0.5);
//必须先用临时变量存,因为后面还要用
t1[i]=d1*d3;t2[i]=d1*d4+d2*d3;t3[i]=d2*d4;
}
for(int i=;i<lmt;i++)
//充分利用虚部空间(可看成逆过程)
b[i]=t2[i],a[i]=t1[i]+t3[i]*Complex(,);
FFT(a,-);FFT(b,-);
for(int i=;i<lmt;i++)
{
ll k1=(ll)a[i].x%MOD,k2=(ll)b[i].x%MOD;
ll k3=(ll)floor(a[i].y/lmt+0.5)%MOD;
res[i]=((k3<<)%MOD+(k2<<)%MOD+k1)%MOD;
}
} int main()
{
scanf("%d%d%d",&n,&m,&MOD);
for(int i=;i<=n;i++)
scanf("%lld",&x),a[i]=Complex(x&,x>>);
for(int i=;i<=m;i++)
scanf("%lld",&x),b[i]=Complex(x&,x>>);
while(lmt<=n+m) lmt<<=,dgt++;
for(int i=;i<lmt;i++)
par[i]=(par[i>>]>>)|((i&)<<(dgt-));
for(int i=;i<lmt;i++)
w[i]=Complex(cos(*M_PI*i/lmt),sin(*M_PI*i/lmt)); solve();
for(int i=;i<=n+m;i++)
printf("%lld ",res[i]);
return ;
}

拆系数FFT

[FFT/NTT/MTT]总结的更多相关文章

  1. FFT/NTT/MTT学习笔记

    FFT/NTT/MTT Tags:数学 作业部落 评论地址 前言 这是网上的优秀博客 并不建议初学者看我的博客,因为我也不是很了解FFT的具体原理 一.概述 两个多项式相乘,不用\(N^2\),通过\ ...

  2. FFT&NTT总结

    FFT&NTT总结 一些概念 \(DFT:\)离散傅里叶变换\(\rightarrow O(n^2)\)计算多项式卷积 \(FFT:\)快速傅里叶变换\(\rightarrow O(nlogn ...

  3. Note -「多项式」基础模板(FFT/NTT/多模 NTT)光速入门

      进阶篇戳这里. 目录 何为「多项式」 基本概念 系数表示法 & 点值表示法 傅里叶(Fourier)变换 概述 前置知识 - 复数 单位根 快速傅里叶正变换(FFT) 快速傅里叶逆变换(I ...

  4. FFT \ NTT总结(多项式的构造方法)

    前言.FFT  NTT 算法 网上有很多,这里不再赘述. 模板见我的代码库: FFT:戳我 NTT:戳我 正经向:FFT题目解题思路 \(FFT\)这个玩意不可能直接裸考的..... 其实一般\(FF ...

  5. [学习笔记&教程] 信号, 集合, 多项式, 以及各种卷积性变换 (FFT,NTT,FWT,FMT)

    目录 信号, 集合, 多项式, 以及卷积性变换 卷积 卷积性变换 傅里叶变换与信号 引入: 信号分析 变换的基础: 复数 傅里叶变换 离散傅里叶变换 FFT 与多项式 \(n\) 次单位复根 消去引理 ...

  6. 快速构造FFT/NTT

    @(学习笔记)[FFT, NTT] 问题概述 给出两个次数为\(n\)的多项式\(A\)和\(B\), 要求在\(O(n \log n)\)内求出它们的卷积, 即对于结果\(C\)的每一项, 都有\[ ...

  7. FFT/NTT模板 既 HDU1402 A * B Problem Plus

    @(学习笔记)[FFT, NTT] Problem Description Calculate A * B. Input Each line will contain two integers A a ...

  8. FFT/NTT基础题总结

    在学各种数各种反演之前把以前做的$FFT$/$NTT$的题整理一遍 还请数论$dalao$口下留情 T1快速傅立叶之二 题目中要求求出 $c_k=\sum\limits_{i=k}^{n-1}a_i* ...

  9. $FFT/NTT/FWT$题单&简要题解

    打算写一个多项式总结. 虽然自己菜得太真实了. 好像四级标题太小了,下次写博客的时候再考虑一下. 模板 \(FFT\)模板 #include <iostream> #include < ...

随机推荐

  1. Linux下clock计时函数学习

    平时在Linux和Winows下都有编码的时候,移植代码的时候免不了发现一些问题.1. 你到底准不准?关于clock()计时函数首先是一段简单的测试代码,功能为测试从文本文件读取数据并赋值给向量最后打 ...

  2. Ubuntu 16.04配置国内高速apt-get更新源【转】

    转自:https://blog.csdn.net/twang0x80/article/details/79782753 Ubuntu 16.04下载软件速度有点慢,因为默认的是从国外下载软件,那就更换 ...

  3. springboot系列十、springboot整合redis、多redis数据源配置

    一.简介 Redis 的数据库的整合在 java 里面提供的官方工具包:jedis,所以即便你现在使用的是 SpringBoot,那么也继续使用此开发包. 二.redidTemplate操作 在 Sp ...

  4. python实现监控windows服务控制开关服务

    转载自 :http://www.jb51.net/article/49106.htm #!/usr/bin/env python #-*- encoding:utf-8 -*- "" ...

  5. 配置samba文件服务器

    1.打开"终端窗口",输入"sudo apt-get update"-->回车-->"输入当前登录用户的管理员密码"--> ...

  6. 017_mac格式化硬盘,mac如何格式化硬盘

    想做一个mac和windows都能识别的系统,推荐设置成什么格式 一.在mac下格式化 在Mac 下,打开右下角应用程序-实用工具-磁盘工具,里面选取你的移动硬盘,然后进行格式化,设置成EXFat格式 ...

  7. centos系统设置通过windows代理上网

    网络环境说明: 物理机windows xp sp3系统 ip:192.168.29.21(通过路由上网,有权限设置proxy给其他机器代理上网) 虚拟机centos5.5系统 ip:192.168.2 ...

  8. S5PV210 看门狗定时和复位

    第一节 S5PV210的看门狗定时器S5PV210上的看门狗定时器相当于一个普通的16bit的定时器,它与PWM定时器的区别是看门狗定时器可以产生reset信号而PWM定时器不能,S5PV210看门狗 ...

  9. 图解 Paxos 一致性协议

    转自:http://blog.jobbole.com/106327/ 前言 Paxos 一致性协议可以说是一致性协议研究的起点,也以难以理解闻名.其实协议本身并没有多难理解,它的难理解性主要体现在:为 ...

  10. java I/O系统 LineNumberReader类

    LineNumbeReader类可以很方便的读取文件的行号 package ch13; import java.io.*; import io.BufferedInputFile; public cl ...