FFT 模板

最新推荐文章于 2022-07-21 14:15:20 发布
最新推荐文章于 2022-07-21 14:15:20 发布
阅读量204 收藏
点赞数 1
分类专栏： CCPC ICPC题目 CF HDU POJ 题目

推荐一篇好的博客：https://blog.csdn.net/qq_38891827/article/details/80281151

一下部分内容转自上面那篇博客。

上面那位朋友说，FFT主要解决两类问题，一类是特殊要求的字符串匹配可构造卷积FFT的，另一类是对两个数组n^2的加法的所有可能结果进行加速。

模板题题目链接

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;
#define maxn 400005//开四倍所有数组。

const double pi=acos(-1.0);
struct complex
{
    double x,y;
    complex(double X=0,double Y=0)
    {
        x=X,y=Y;
    }
} a[maxn],b[maxn];
complex operator + (complex a,complex b)
{
    return complex(a.x+b.x,a.y+b.y);
}
complex operator - (complex a,complex b)
{
    return complex(a.x-b.x,a.y-b.y);
}
complex operator * (complex a,complex b)
{
    return complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);
}
int S,T,n,m,L,R[maxn],ans[maxn];
long long F[maxn];//存储多项式相乘结果的系数从0-n
double f[maxn],g[maxn];

void FFT(complex a[maxn],int opt)
{
    for (int i=0; i<n; ++i)
        if (i<R[i]) swap(a[i],a[R[i]]);
    for (int k=1; k<n; k<<=1)
    {
        complex wn=complex(cos(pi/k),opt*sin(pi/k));
        for (int i=0; i<n; i+=(k<<1))
        {
            complex w=complex(1,0);
            for (int j=0; j<k; ++j,w=w*wn)
            {
                complex x=a[i+j],y=w*a[i+j+k];
                a[i+j]=x+y,a[i+j+k]=x-y;
            }
        }
    }
}
void calc(int opt)
{
    FFT(a,1);
    FFT(b,1);
    for (int i=0; i<=n; ++i)
        a[i]=a[i]*b[i];
    FFT(a,-1);
    for (int i=0; i<=n; ++i)//上限为n，在运用时灵活修改。
        F[i]=(long long)(a[i].x/n+0.5)*opt;
}
void solve()
{
/*
    多项式f和多项式g的乘积
    其中，多项式f的次数为0到S，多项式g的次数为0到T
    结果存在数组F中，F的系数为0到S+T
    时间：O(n logn)
*/
    m=S+T;
    L=0;//多组输入时，L要初始化为0
    for (n=1; n<=m; n<<=1) ++L;
    for (int i=0; i<n; ++i)
        R[i]=(R[i>>1]>>1)|((i&1)<<(L-1));
    for (int i=0; i<=n; ++i)
        a[i]=complex(1.0*f[i],0.0),b[i]=complex(1.0*g[i],0.0);
    calc(1);
}
int main()
{
    scanf("%d%d",&S,&T);
    for(int i=0; i<=S; i++)
        scanf("%lf",&f[i]);
    for(int i=0; i<=T; i++)
        scanf("%lf",&g[i]);
    solve();
    for(int i=0; i<=S+T; i++)
        printf("%d ",F[i]);
    return 0;
}

FFT题目链接

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#define mem(a,b) memset((a),b,sizeof(a))
typedef long long ll;
const ll inf=1e18;
const int maxn=4000010;
using namespace std;
char aa[1000010],bb[1000010];

const double pi=acos(-1.0);
struct complex
{
    double x,y;
    complex(double X=0,double Y=0)
    {
        x=X,y=Y;
    }
} a[maxn],b[maxn];
complex operator + (complex a,complex b)
{
    return complex(a.x+b.x,a.y+b.y);
}
complex operator - (complex a,complex b)
{
    return complex(a.x-b.x,a.y-b.y);
}
complex operator * (complex a,complex b)
{
    return complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);
}
int S,T,n,m,L,R[maxn];
int F[maxn],FF[maxn];//存储多项式相乘结果的系数从0-n
double f[maxn],g[maxn];

void FFT(complex a[maxn],int opt)
{
    for (int i=0; i<n; ++i)
        if (i<R[i]) swap(a[i],a[R[i]]);
    for (int k=1; k<n; k<<=1)
    {
        complex wn=complex(cos(pi/k),opt*sin(pi/k));
        for (int i=0; i<n; i+=(k<<1))
        {
            complex w=complex(1,0);
            for (int j=0; j<k; ++j,w=w*wn)
            {
                complex x=a[i+j],y=w*a[i+j+k];
                a[i+j]=x+y,a[i+j+k]=x-y;
            }
        }
    }
}
void calc(int opt)
{
    FFT(a,1);
    FFT(b,1);
    for (int i=0; i<=n; ++i)
        a[i]=a[i]*b[i];
    FFT(a,-1);
    for (int i=0; i<=n; ++i)//上限为n，在运用时灵活修改。
        F[i]=(long long)(a[i].x/n+0.5)*opt;
}
void solve()
{
/*
    多项式f和多项式g的乘积
    其中，多项式f的系数为0到S，多项式g的系数为0到T
    结果存在数组F中，F的系数为0到S+T
    时间：O(n logn)
*/
    m=S+T;
    for (n=1; n<=m; n<<=1) ++L;
    for (int i=0; i<n; ++i)
        R[i]=(R[i>>1]>>1)|((i&1)<<(L-1));
    for (int i=0; i<=n; ++i)
        a[i]=complex(1.0*f[i],0.0),b[i]=complex(1.0*g[i],0.0);
    calc(1);
}

int main()
{
    scanf("%s",aa);
    scanf("%s",bb);
    int lena=strlen(aa),lenb=strlen(bb);
    int ans=0;
    mem(FF,0);

    //S     P L
    L=0;
    mem(f,0);mem(g,0);
    for(int i=0;i<lena;i++)
    {
        if(aa[i]=='P'||aa[i]=='L')
            f[i]=1;
        else
            f[i]=0;
    }
    for(int i=0;i<lenb;i++)
    {
        if(bb[i]=='S')
            g[lenb-i-1]=1;
        else
            g[lenb-i-1]=0;
    }
    S=lena-1;
    T=lenb-1;
    solve();
    for(int i=0;i<=S+T;i++)
        FF[i]+=F[i];

    //P     R K
    L=0;
    mem(f,0);mem(g,0);
    for(int i=0;i<lena;i++)
    {
        if(aa[i]=='R'||aa[i]=='K')
            f[i]=1;
        else
            f[i]=0;
    }
    for(int i=0;i<lenb;i++)
    {
        if(bb[i]=='P')
            g[lenb-i-1]=1;
        else
            g[lenb-i-1]=0;
    }
    S=lena-1;
    T=lenb-1;
    solve();
    for(int i=0;i<=S+T;i++)
        FF[i]+=F[i];

    //R     L S
    L=0;
    mem(f,0);mem(g,0);
    for(int i=0;i<lena;i++)
    {
        if(aa[i]=='L'||aa[i]=='S')
            f[i]=1;
        else
            f[i]=0;
    }
    for(int i=0;i<lenb;i++)
    {
        if(bb[i]=='R')
            g[lenb-i-1]=1;
        else
            g[lenb-i-1]=0;
    }
    S=lena-1;
    T=lenb-1;
    solve();
    for(int i=0;i<=S+T;i++)
        FF[i]+=F[i];

    //L     K P
    L=0;
    mem(f,0);mem(g,0);
    for(int i=0;i<lena;i++)
    {
        if(aa[i]=='K'||aa[i]=='P')
            f[i]=1;
        else
            f[i]=0;
    }
    for(int i=0;i<lenb;i++)
    {
        if(bb[i]=='L')
            g[lenb-i-1]=1;
        else
            g[lenb-i-1]=0;
    }
    S=lena-1;
    T=lenb-1;
    solve();
    for(int i=0;i<=S+T;i++)
        FF[i]+=F[i];

    //K     S R
    L=0;
    mem(f,0);mem(g,0);
    for(int i=0;i<lena;i++)
    {
        if(aa[i]=='S'||aa[i]=='R')
            f[i]=1;
        else
            f[i]=0;
    }
    for(int i=0;i<lenb;i++)
    {
        if(bb[i]=='K')
            g[lenb-i-1]=1;
        else
            g[lenb-i-1]=0;
    }
    S=lena-1;
    T=lenb-1;
    solve();
    for(int i=0;i<=S+T;i++)
        FF[i]+=F[i];

    ans=0;
    for(int i=T;i<=S;i++)
        ans=max(ans,FF[i]);
    cout<<ans<<endl;

    return 0;
}

FFT题目链接 

#include<bits/stdc++.h>
#define mem(a,b) memset((a),b,sizeof(a))
typedef long long ll;
const ll inf=1e18;
const int N=(1<<15)+10;
using namespace std;
char s[1000010];
#define maxn 4000005//开四倍所有数组。
const double pi=acos(-1.0);
struct Complex
{
    double x,y;
    Complex(double X=0,double Y=0)
    {
        x=X,y=Y;
    }
} a[maxn],b[maxn];
Complex operator + (Complex a,Complex b)
{
    return Complex(a.x+b.x,a.y+b.y);
}
Complex operator - (Complex a,Complex b)
{
    return Complex(a.x-b.x,a.y-b.y);
}
Complex operator * (Complex a,Complex b)
{
    return Complex(a.x*b.x-a.y*b.y,a.x*b.y+a.y*b.x);
}
int S,T,n,m,L,R[maxn],ans[maxn];
long long F[maxn];//存储多项式相乘结果的系数从0-n
double f[maxn],g[maxn];

void FFT(Complex a[maxn],int opt)
{
    for (int i=0; i<n; ++i)
        if (i<R[i]) swap(a[i],a[R[i]]);
    for (int k=1; k<n; k<<=1)
    {
        Complex wn=Complex(cos(pi/k),opt*sin(pi/k));
        for (int i=0; i<n; i+=(k<<1))
        {
            Complex w=Complex(1,0);
            for (int j=0; j<k; ++j,w=w*wn)
            {
                Complex x=a[i+j],y=w*a[i+j+k];
                a[i+j]=x+y,a[i+j+k]=x-y;
            }
        }
    }
}
void calc(int opt)
{
    FFT(a,1);
    FFT(b,1);
    for (int i=0; i<=n; ++i) a[i]=a[i]*b[i];
    FFT(a,-1);
    for (int i=0; i<=n; ++i)//上限为n，在运用时灵活修改。
        F[i]=(long long)(a[i].x/n+0.5)*opt;
}

int main()
{
    scanf("%s",s+1);
    int len=strlen(s+1);
    mem(f,0);
    mem(g,0);
    S=len+1;
    T=len+1;
    int p=0;
    for(int i=1;i<=len;i++)
    {
        if(s[i]=='A')
            f[i]=1;
        else
            {g[len-i]=1;p++;}
    }
    m=S+T;
    L=0;
    for (n=1; n<=m; n<<=1) ++L;
    for (int i=0; i<n; ++i)
        R[i]=(R[i>>1]>>1)|((i&1)<<(L-1));
    for (int i=0; i<=n; ++i)
        a[i]=Complex(1.0*f[i],0.0),b[i]=Complex(1.0*g[i],0.0);
    calc(1);
    for(int i=len+1; i<=len+len-1; i++)
        printf("%d\n",F[i]);
    return 0;
}

 

flyzer
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快速傅里叶变化（FFT）含模板
zhz的博客
07-04 502
快速傅里叶变化（FFT） 资料来源：https://www.bilibili.com/video/BV1Y7411W73U 前置知识索引 FFT的核心算法是基于复数和单位根的，并且在算法竞赛中FFT的最普遍应用是求i多项式乘法，或者是卷积。 复数 Complex Number ​ 定义：z=a+bi其中a,b∈R，i=n加法法则：(a+bi)+(c+di)=(a+c)+(b+d)i乘法法则：（a+bi)(c+di)=(ac−bd)+(ad+bc)i欧拉定理：eiθ=cos⁡θ+isin⁡θ 定义：z =
FFT模板
01-06
P3803 多项式乘法模板（FFT） 题意： 给定n次和m次多项式的系数，要求计算这两个多项式乘积的系数 code： #include using namespace std; const double P=acos(-1.0); struct CC{//复数 double x,y; CC(double xx=...
FFT模板-附详细注释
pursuit的博客
08-05 840
学习自：快速傅里叶变换(FFT)详解,【学习笔记】超简单的快速傅里叶变换（FFT）（含全套证明）。 FFT模板 /** *@filename:FFT *@author: pursuit *@created: 2021-08-05 20:57 **/ #include <bits/stdc++.h> #define debug(a) cout << "debug : " << (#a)<< " = " << a << en
FFT快速傅里叶变换在字符串匹配中的应用详解【附模板，例题】五千字详解
jisuanji2606414的博客
07-21 827
第一项来说，一个确定的A串其值是定值T，第二项来说，其意义是从x结束的前缀里面，减去x-m的前缀，剩下x-m+1到x的部分G，第三部分，m-i-1+x-m+i+1=x分别设为i,j,0
FFT模板+题目
qq_36102055的博客
08-14 236
#include<iostream> #include<cstdio> #include<cmath> using namespace std; const int MAXN=1e7+10; const double Pi=acos(-1.0); struct complex{ double x,y; complex (double xx=0,double yy=0){x=xx,y=yy;} }a[MAXN],b[MAXN]; complex oper
洛谷 P3803 FFT
Ambrumf的博客
01-09 472
思路：FFT模板 #include <bits/stdc++.h> using namespace std; typedef long long ll; const double PI = acos(-1); const int N = 1e7 + 7; int n, m; int res, ans[N]; int limit = 1;// 补齐的2的整数幂N int L;// 二进制的位数 int R[N];// 二进制翻转 struct Complex { double x, y;
FFT滤波实验
03-27
此外，还可以自定义滤波器模板，以满足特定的滤波需求。 4. **逆傅里叶变换**：应用逆FFT (IFFT) 将处理后的频域图像转换回时域，生成滤波后的图像。 5. **后处理**：最后，可能需要对结果图像进行一些后处理，...
fft.rar_fft_fft变换
09-20
**快速傅里叶变换(FFT)详解** 快速傅里叶变换（Fast Fourier Transform，简称FFT）是一种用于计算离散傅里叶变换（Discrete ...在实际编程中，结合`COMPLEX`模板和`VECTOR`等数据结构，可以方便地实现和应用FFT算法。
fft.rar_fft_matlab fft
09-22
使用模板类和STL容器可以帮助提高代码的可读性和复用性。 5. 调试和优化C++ FFT：为了提升C++ FFT的效率，开发者可能需要进行性能分析，识别瓶颈，并使用诸如OpenMP这样的库进行并行化，或者采用其他优化技术，如...
FFT
03-29
在C++中，可以使用标准模板库(STL)以及复数类来实现FFT。以下是一个简单的基于Cooley-Tukey算法的FFT实现步骤： 1. 定义复数类：包含实部和虚部，提供复数运算的重载方法。 2. 编写递归的FFT函数：接受一个复数...
HDU - 1408 FFT模板题
Bahuia的博客
03-20 863
题意： 两个大数相乘。 思路： 这题是典型的FFT。 所谓FFT，也就是快速傅里叶变换，是一种加速两个多项式系数相乘的算法，可以通过插值表示多项式的思想，将多项式从系数形式转化成点值形式，点值形式的多项式相乘只需要O(n)，而FFT的关键就在于点值形式和系数形式之间的相互转化，可以利用分治的思想达到O(logn)的复杂度。 关于FFT的详细推导可以学习算法导论第30章。 一个题目如果需
fft模板(例题：hdu4609）
weixin_43965698的博客
05-25 255
求A(x)*B(x) // fft模板.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include"pch.h" #include <iostream> #include<algorithm> #include<iostream> #include<string> #include<cstdio>...
洛谷 P3803 【模板】多项式乘法（FFT）
sillyf的博客
01-11 499
题面 题解 fft模板题 单向膜拜: 从多项式乘法到快速傅里叶变换 FFT 学习笔记 大致理解为将多项式从系数表示法转化为点值表示法然后再变回系数表示法 #include #include #include #define N 2621450 #define pi acos(-1.0) using namespace std; int n,m,len,R[N]; struc
【模板】FFT
weixin_30266885的博客
08-09 59
题意简述 求两个多项式的卷积 题解思路 先将多项式转化为点值表示法，再相乘，最后转化为系数表示法 优化：三次变两次 代码（递归） #include <cmath> #include <cstdio> const int N=4000010; const double Pi=acos(-1.0); int n,m,len=1; struct Complex { ...
FFT（最详细最通俗的入门手册）
热门推荐
逐梦者
07-24 6万+
声明首先，我需要声明，本文是在转载的基础上稍微修饰的，经过原创作者 ZLH_HHHH（佐理慧学姐） 的许可方才转载并修饰的，由于我就是初学者，并且是数学渣滓，所以我学姐建议我写一下残疾人手册，我当然是欣然接受！！！正文：文章写的有点急。有错误的地方望指出 我学习 FFT 是一个比较慢的过程。 期间反反复复。 我写这篇博文只是一个非常浅显的理解。同时也可以帮助初学者在学习FFT的时候。有所偏重。避免
快速傅里叶(FFT)题表
OZY的博客
11-23 4714
前言 最近终于学了FFT 以前被scy逼着学过一次没有学会，这次终于好一点了 在这里大致放一下一些FFT的题目 题表 uoj34 多项式乘法，这个估计是大多数人的入门题了吧 codevs3123 大整数高精度，其实和上面那题是差不多的 bzoj3527 化一下式子，然后两个FFT就可以得出答案了 bzoj3771 这题的话，也不是很难 你只需要分别讨论选择一个，选择两...
请用C++写一个FFT模板
最新发布
04-11
好的，以下是C语言中的FFT模板： ```c #include #include typedef struct _complex { double real, imag; } complex; const double PI = atan(1.0) * 4; void fft(complex *x, int N) { if (N ) return; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值