FFT（快速傅立叶变换）

最新推荐文章于 2025-05-25 11:07:00 发布
最新推荐文章于 2025-05-25 11:07:00 发布
阅读量998 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 高级算法 数论 文章标签： fft
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ACMer_ZP/article/details/53455246

大佬博客
hdu 4609
题意:给定一个数组，问从其中选3个值能构成三角形的概率是多少。
思路:先求出选两个之和的情况，然后枚举选取的最长边，根据三角形的三边定理来求解。
选两个之和的情况及是，先将长度相同的统计起来，然后求这个数组的卷积，其值就是和为i的有多少个，也就是代码中的num数组。

/*
这里解释一下什么是两个数组的卷积，假如给定两个一元多项式，
他们两个多项式的系数会成为两个数组，而这两个多项式相乘，
会形成另一个一元多项式，而这个一元多项式的各项系数就是上面
两个数组的卷积。
*/
#include <cmath>//fft求a数组和b数组的卷积
#include <cstdio>//num[i]存的就是卷积的最后结果也就是次幂为i的多项式系数是多少
#include <cstring>//比如num[2]=3代表的就是x^2前面的系数是3
#include <iostream>
#include <algorithm>
using namespace std;
#define LL long long
const double pi=acos(-1.0);
const int maxn=400040;
int x[maxn];
LL num[maxn];//存储求得的卷积结果
LL sum[maxn];//前缀和数组
struct Complex//定义一个复数类及其运算
{
    double x,y;//实部，虚部
    Complex(double _x=0.0,double _y=0.0)
    {
        x=_x;
        y=_y;
    }
    Complex operator -(const Complex &b)const
    {
        return Complex(x-b.x,y-b.y);
    }
    Complex operator +(const Complex &b)const
    {
        return Complex(x+b.x,y+b.y);
    }
    Complex operator *(const Complex &b)const
    {
        return Complex(x*b.x-y*b.y,x*b.y+y*b.x);
    }
} x1[maxn],x2[maxn];
void Rader(Complex y[],int len)//雷德算法--倒位序
{
    int i,j,k;
    for(i=1,j=len/2; i<len-1; i++)
    {
        if(i<j) swap(y[i],y[j]);
        k=len/2;
        while(j>=k)
        {
            j-=k;
            k/=2;
        }
        if(j<k) j+=k;
    }
}
void FFT(Complex y[],int len,int on)//FFT实现
{
    Rader(y,len);
    for(int h=2; h<=len; h<<=1)
    {
        Complex wn(cos(-on*2*pi/h),sin(-on*2*pi/h));
        for(int j=0; j<len; j+=h)
        {
            Complex w(1,0);//旋转因子
            for(int k=j; k<j+h/2; k++)
            {
                Complex u=y[k];
                Complex t=w*y[k+h/2];
                y[k]=u+t;//蝴蝶合并操作
                y[k+h/2]=u-t;
                w=w*wn;//更新旋转因子
            }
        }
    }
    if(on==-1)
    {
        for(int i=0; i<len; i++)
            y[i].x/=len;
    }
}
void Conv(Complex a[],Complex b[],int len)//求卷积
{
    FFT(a,len,1);
    FFT(b,len,1);//求值 将系数表示转化为点值表示
    for(int i=0; i<len; i++)
        a[i]=a[i]*b[i];
    FFT(a,len,-1);//插值 将点值表示转化为系数表示
    for(int i=0; i<len; i++)
        num[i]=(LL)(a[i].x+0.5);
}
int init(LL a[],LL b[],int n)
{
    int len1=x[n-1]+1,len2=x[n-1]+1;
    int len=1;//最后的总长度
    while(len<2*len1||len<2*len2) len<<=1;
    for(int i=0; i<len1; i++)
        x1[i]=Complex(a[i],0);
    for(int i=len1; i<len; i++)
        x1[i]=Complex(0,0);
    for(int i=0; i<len2; i++)
        x2[i]=Complex(b[i],0);
    for(int i=len2; i<len; i++)
        x2[i]=Complex(0,0);
    return len;
}
int main()
{
    int ncase;
    scanf("%d",&ncase);
    while(ncase--)
    {
        memset(num,0,sizeof(num));
        int n;
        scanf("%d",&n);
        for(int i=0; i<n; i++)
        {
            scanf("%d",&x[i]);
            num[x[i]]++;
        }
        sort(x,x+n);
        int len=init(num,num,n);
        Conv(x1,x2,len);
        for(int i=0; i<n; i++) //减去2次选的同一个数
            num[x[i]+x[i]]--;
        for(int i=1; i<=len; i++) num[i]/=2; //选1 2和选2 1是一样的所以除2
        sum[0]=0;
        for(int i=1; i<=len; i++) //num的前缀和
            sum[i]=sum[i-1]+num[i];
        LL ans=0;
        for(int i=0; i<n; i++) //取3个a[i]为最长边的取法
        {
            ans+=sum[len]-sum[x[i]];//a[i]是最大的所有情况
            ans-=(LL)(n-1-i)*i;//一个比a[i]大一个比a[i]小
            ans-=(LL)(n-1);//一个取a[i]另一个取其他的
            ans-=(LL)(n-1-i)*(n-2-i)/2;//两个都比a[i]大
        }
        LL all=1ll*n*(n-1)*(n-2)/6;//所有情况
        printf("%.7lf\n",1.0*ans/all);
    }
}

hdu 1402
题意:大数乘法卡时间要nlognFFT优化

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define LL long long
const double pi=acos(-1.0);
const int maxn=500050;
char s1[maxn],s2[maxn];
int num[maxn];//存储求得的卷积结果
struct Complex//定义一个复数类及其运算
{
    double x,y;//实部，虚部
    Complex(double _x=0.0,double _y=0.0)
    {
        x=_x;
        y=_y;
    }
    Complex operator -(const Complex &b)const
    {
        return Complex(x-b.x,y-b.y);
    }
    Complex operator +(const Complex &b)const
    {
        return Complex(x+b.x,y+b.y);
    }
    Complex operator *(const Complex &b)const
    {
        return Complex(x*b.x-y*b.y,x*b.y+y*b.x);
    }
} x1[maxn],x2[maxn];
void Rader(Complex y[],int len)//雷德算法--倒位序
{
    int i,j,k;
    for(i=1,j=len/2; i<len-1; i++)
    {
        if(i<j) swap(y[i],y[j]);
        k=len/2;
        while(j>=k)
        {
            j-=k;
            k/=2;
        }
        if(j<k) j+=k;
    }
}
void FFT(Complex y[],int len,int on)//FFT实现
{
    Rader(y,len);
    for(int h=2; h<=len; h<<=1)
    {
        Complex wn(cos(-on*2*pi/h),sin(-on*2*pi/h));
        for(int j=0; j<len; j+=h)
        {
            Complex w(1,0);//旋转因子
            for(int k=j; k<j+h/2; k++)
            {
                Complex u=y[k];
                Complex t=w*y[k+h/2];
                y[k]=u+t;//蝴蝶合并操作
                y[k+h/2]=u-t;
                w=w*wn;//更新旋转因子
            }
        }
    }
    if(on==-1)
    {
        for(int i=0; i<len; i++)
            y[i].x/=len;
    }
}
int len;
void Conv()//求卷积
{
    FFT(x1,len,1);
    FFT(x2,len,1);//求值 将系数表示转化为点值表示
    for(int i=0; i<len; i++)
        x1[i]=x1[i]*x2[i];
    FFT(x1,len,-1);//插值 将点值表示转化为系数表示
    for(int i=0; i<len; i++)
        num[i]=x1[i].x+0.5;
}
void init()
{
    int len1=strlen(s1),len2=strlen(s2);
    len=1;
    while(len<2*len1||len<2*len2) len<<=1;
    for(int i=0; i<len1; i++)
        x1[i]=Complex(s1[len1-i-1]-'0',0.0);
    for(int i=len1; i<len; i++)
        x1[i]=Complex(0.0,0.0);
    for(int i=0; i<len2; i++)
        x2[i]=Complex(s2[len2-i-1]-'0',0.0);
    for(int i=len2; i<len; i++)
        x2[i]=Complex(0.0,0.0);
}
void solve()
{
    for(int i=0;i<=len;i++)
    {
        num[i+1]+=num[i]/10;
        num[i]%=10;
    }
    int f=0;
    for(int i=len;i>=0;i--)
    {
        if(num[i])
        {
            for(int j=i;j>=0;j--)
                f=1,printf("%d",num[j]);
            break;
        }
    }
    if(!f) printf("0");
    printf("\n");
}
int main()
{
    while(~scanf("%s%s",s1,s2))
    {
        memset(num,0,sizeof(num));
        init();
        Conv();
        solve();
    }
}
快速傅立叶变换
Xia Qiaolin - 优快云
06-01 1146
为什么要进行傅里叶变换，其物理意义是什么？傅立叶变换是数字信号处理领域一种很重要的算法。要知道傅立叶变换算法的意义，首先要了解傅立叶原理的意义。傅立叶原理表明：任何连续测量的时序或信号，都可以表示为不同频率的正弦波信号的无限叠加。而根据该原理创立的傅立叶变换算法利用直接测量到的原始信号，以累加方式来计算该信号中不同正弦波信号的频率、振幅和相位。和傅立叶变换算法对应的是反傅立叶变换算法。该反变换从本
十分简明易懂的FFT（快速傅里叶变换）
热门推荐
路人黑的纸巾
08-07 60万+
FFT有什么用 快速傅里叶变换 (fast Fourier transform),即利用计算机计算离散傅里叶变换（DFT)的高效、快速计算方法的统称，简称FFT。快速傅里叶变换是1965年由J.W.库利和T.W.图基提出的。采用这种算法能使计算机计算离散傅里叶变换所需要的乘法次数大为减少，特别是被变换的抽样点数N越多，FFT算法计算量的节省就越显著。 FFT（Fast Fouri...
快速傅里叶变换
qq_43776408的博客
07-23 971
快速傅里叶变换叫FFT，是DFT的快速算法，只是改进以下算的方法而已 对于DFT变换而言 每一个k值都对应着N次相乘，以及N-1次相加 而又有N个k值，因为k的取值范围是0到N-1，所以有N的平方个乘机项，和N（N-1）项加式 FFT分为DIT和DFF，前者是基于时间的，也就是时域抽选法，后者是频域抽选法 我们学的是DIT 做几点DFT变换，其周期就是几点 什么是基2？ 就是序列的长度是2的整数倍...
并行FFT算法实现与优化：MPI实践
最新发布
weixin_35950531的博客
05-25 1041
MPI（Message Passing Interface）是一种消息传递接口的规范，它为并行计算提供了一种标准化的方式，旨在利用多处理器和网络分布式内存计算机系统。自1990年代初期开发以来，MPI成为了高性能计算领域广泛采纳的标准。版本1.0在1994年发布，历经多年的发展和多个版本的迭代，MPI不断优化和扩展其功能，以适应不断增长的并行计算需求。MPI的版本演进表现在对性能的提升、更丰富的通信操作、以及更好的可移植性和可扩展性上。
fft快速傅里叶变换，消除图像干扰，halcon代码
02-27
快速傅里叶变换（FFT）是数字信号处理领域中一种重要的算法，用于将信号从时域转换到频域。在图像处理中，FFT被广泛应用于分析图像的频率特性，识别和去除噪声。在这个场景中，我们看到的是使用Halcon编程语言进行...
python 实现FFT快速傅立叶变换算法
luthane的博客
08-05 4184
FFT（快速傅里叶变换）是计算离散傅里叶变换（DFT）及其逆变换的一种高效算法。DFT是一种将信号从时域转换到频域的数学工具，而FFT通过减少计算量来加速这一过程。FFT的基本思想FFT利用了DFT中的对称性和周期性，通过分而治之的策略将DFT分解为更小的DFT，从而显著减少计算复杂度。对于长度为N的序列，直接计算DFT的复杂度是O(N^2)，而FFT的复杂度可以降低到O(N log N)。FFT的算法步骤（以Cooley-Tukey算法为例）
数字信号处理FFT快速傅立叶变换MATLAB实现+源码
07-02
数字信号处理FFT快速傅立叶变换MATLAB实现+源码 数字信号处理FFT快速傅立叶变换MATLAB实现+源码 数字信号处理FFT快速傅立叶变换MATLAB实现+源码 数字信号处理FFT快速傅立叶变换MATLAB实现+源码 数字信号处理FFT...
fft快速傅里叶变换蝶形算法详解_fft
09-25
快速傅里叶变换（FFT）是离散傅里叶变换（DFT）的一种高效计算方法，广泛应用于信号处理、图像处理、数值计算等多个领域。本文将深入解析FFT中的蝶形算法，帮助读者理解其原理与应用。 傅里叶变换是一种将时域信号...
快速傅立叶变换（Fast Fourier Transform）
jubincn的专栏
10-15 1259
FFT算法是由J.W. Cooley和J. W. Tukey在论文”Analgorithm for the machine calculation of complex Fourier Series”中提出的。FFT是基于ComplexDFT来实现的。 通过ComplexDFT来计算Real DFT 尽管FFT算法是基于ComplexDFT实现的，但我们仍可以用其来计算RealDFT，因...
快速傅里叶变换（Fast Fourier Transformation）
ZergWang's Blog
10-04 1673
1.问题引入 当两个多项式f(x)、g(x)相乘时，最直接的解决方法是：枚举f(x)的每一项，与g(x)的每一项分别相乘，再合并同类项，时间复杂度为O(n^2)。实际上，我们可以使用快速傅里叶变换，将时间复杂度优化至O(n*log2​n)。 2.背景知识 1.点值表示法 对于一个有n项的多项式，既可以使用n个系数来表示它（这n个系数可表示唯一多项式）：f(x)={a0​,a1​,a2​,....
快速傅里叶变换（FFT）
qq_50702668的博客
08-18 3048
FFTFFTFFT是在nlognnlognnlogn的时间复杂度内来解决两个多项式卷积的问题 多项式性质：用图像上的任意nnn个不同点，可唯一确定一个n−1n-1n−1次多项式 FFTFFTFFT是特殊取nnn个点，将多项式表示法转换为点表示法 设A(x)=a0x0+a1x1+a2x2+...+an−1xn−1A(x)=a_0x^0 + a_1x^1 + a_2x^2 + ... +a_{n-1}x^{n-1}A(x)=a0​x0+a1​x1+a2​x2+...+an−1​xn−1 取nnn个点，是复数域的
快速傅里叶变换(FFT)
weixin_33971130的博客
06-25 244
数学——快速傅里叶变换(FFT) Shan xizeng 基础知识 快速傅里叶变换，用来求出两个多项式相乘，如果暴力相乘，时间复杂度为\(O(n^2 )\)，使用快速傅里叶变换，可以优化到\(O(n log n)\)。 准备知识： 多项式：设\(A(x)\)表示一个n-1次多项式，则\(A(x)=a_0x^0+a_1x^1+\cdots+a_nx^n\) 多项式的表示方法： 一是用系数表示法，表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值