快速傅里叶变换（FFT）

最新推荐文章于 2020-11-27 09:17:09 发布
最新推荐文章于 2020-11-27 09:17:09 发布
阅读量130 收藏
点赞数
分类专栏： 数论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/micaudience/article/details/108197290
版权

板子

const int N = 4e5 + 10;
const double PI = acos(-1.0);
struct Complex{
	double x, y;
	Complex (){}
	Complex (double u, double v){	x = u, y = v;}
	Complex operator + (const Complex & other) const{ return Complex (x + other.x, y + other.y);}
	Complex operator - (const Complex & other) const{ return Complex (x - other.x, y - other.y);}
	Complex operator * (const Complex & other) const{ return Complex(x * other.x - y * other.y, x * other.y + y * other.x);}
	
}A[N], B[N];
int rev[N];
int FFT_pre(int n) //n = |A|+|B|
{
	int lim = 1, L = 0;
	while(lim <= n)	lim <<= 1, L++;
	for(int i = 0; i < lim; i++)	
		rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (L - 1));
	return lim;
}
void FFT(Complex a[], int lim, int opt)
{
	for(int i = 0; i < lim; i++)
		if(i < rev[i])
			swap(a[i], a[rev[i]]);
	for(int i = 2; i <= lim; i <<= 1)
	{
		int tmp = i >> 1;
		Complex wn = Complex(cos(2 * PI / i), opt * sin(2 * PI / i));
		for(int j = 0; j < lim; j += i)
		{
			Complex w = Complex(1.0, 0.0);
			for(int k = 0; k < tmp; k++)
			{
				Complex tmp1 = a[j + k];
				Complex tmp2 = w * a[j + k + tmp];
				a[j + k] = tmp1 + tmp2;
				a[j + k + tmp] = tmp1 - tmp2;
				w = w *wn;
			}
		}
	}
	if(opt == -1)
		for(int i = 0; i < lim; i++)
			a[i].x /= lim;
}

题目

[ZJOI2014]力

题意：给电荷量，求场强。即给 q j q_{j} qj​， F j = ∑ i = 1 j − 1 q i ∗ q j ( i − j ) 2 − ∑ i = j + 1 n q i ∗ q j ( i − j ) 2 F_{j}=\sum_{i = 1}^{j-1}\frac{q_{i}*q_{j}}{(i-j)^{2}}-\sum_{i = j+1}^{n}\frac{q_{i}*q_{j}}{(i-j)^{2}} Fj​=∑i=1j−1​(i−j)2qi​∗qj​​−∑i=j+1n​(i−j)2qi​∗qj​​, E j = F j q j E_{j}=\frac{F_{j}}{q_{j}} Ej​=qj​Fj​​，求 E j E_{j} Ej​
思路： E j = ∑ i = 1 j − 1 q i ( i − j ) 2 − ∑ i = j + 1 n q i ( i − j ) 2 E_{j}=\sum_{i = 1}^{j-1}\frac{q_{i}}{(i-j)^{2}}-\sum_{i = j+1}^{n}\frac{q_{i}}{(i-j)^{2}} Ej​=i=1∑j−1​(i−j)2qi​​−i=j+1∑n​(i−j)2qi​​
左边加一个j，右边减一个j，
= ∑ i = 1 j q i ( i − j ) 2 − ∑ i = j n q i ( i − j ) 2 =\sum_{i = 1}^{j}\frac{q_{i}}{(i-j)^{2}}-\sum_{i = j}^{n}\frac{q_{i}}{(i-j)^{2}} =i=1∑j​(i−j)2qi​​−i=j∑n​(i−j)2qi​​
令 q 0 = 0 q_{0}=0 q0​=0，
= ∑ i = 0 j q i ( i − j ) 2 − ∑ i = j n q i ( i − j ) 2 =\sum_{i = 0}^{j}\frac{q_{i}}{(i-j)^{2}}-\sum_{i = j}^{n}\frac{q_{i}}{(i-j)^{2}} =i=0∑j​(i−j)2qi​​−i=j∑n​(i−j)2qi​​
令 k = i − j k=i-j k=i−j，
= ∑ i = 0 j q i ( i − j ) 2 − ∑ k = 0 n − j q k + j k 2 =\sum_{i = 0}^{j}\frac{q_{i}}{(i-j)^{2}}-\sum_{k = 0}^{n-j}\frac{q_{k+j}}{k^{2}} =i=0∑j​(i−j)2qi​​−k=0∑n−j​k2qk+j​​
翻转q，令 Q i = q n − i Q_{i} = q_{n-i} Qi​=qn−i​，则 q k + j = Q ( n − j ) − i q_{k+j}=Q_{(n-j)-i} qk+j​=Q(n−j)−i​，
= ∑ i = 0 j q i ( i − j ) 2 − ∑ k = 0 n − j Q ( n − j ) − i k 2 =\sum_{i = 0}^{j}\frac{q_{i}}{(i-j)^{2}}-\sum_{k = 0}^{n-j}\frac{Q_{(n-j)-i}}{k^{2}} =i=0∑j​(i−j)2qi​​−k=0∑n−j​k2Q(n−j)−i​​
卷就完事了。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
const int N = 4e5 + 10;
const double PI = acos(-1.0);
struct Complex{
	double x, y;
	Complex (){}
	Complex (double u, double v){	x = u, y = v;}
	Complex operator + (const Complex & other) const{ return Complex (x + other.x, y + other.y);}
	Complex operator - (const Complex & other) const{ return Complex (x - other.x, y - other.y);}
	Complex operator * (const Complex & other) const{ return Complex(x * other.x - y * other.y, x * other.y + y * other.x);}
	
}a[N], b[N], c[N];
int rev[N];
void FFT(Complex a[], int lim, int opt)
{
	for(int i = 0; i < lim; i++)
		if(i < rev[i])
			swap(a[i], a[rev[i]]);
	for(int i = 2; i <= lim; i <<= 1)
	{
		int tmp = i >> 1;
		Complex wn = Complex(cos(2 * PI / i), opt * sin(2 * PI / i));
		for(int j = 0; j < lim; j += i)
		{
			Complex w = Complex(1.0, 0.0);
			for(int k = 0; k < tmp; k++)
			{
				Complex tmp1 = a[j + k];
				Complex tmp2 = w * a[j + k + tmp];
				a[j + k] = tmp1 + tmp2;
				a[j + k + tmp] = tmp1 - tmp2;
				w = w *wn;
			}
		}
	}
	if(opt == -1)
		for(int i = 0; i < lim; i++)
			a[i].x /= lim;
}
int main()
{
	int n;
	scanf("%d", &n);
	for(int i = 1; i <= n; i++)
		scanf("%lf", &a[i].x);
	for(int i = 1; i <= n; i++)
	{
		b[i].x = (double)(1.0 / i / i);
		c[n - i].x = a[i].x;
	}
	int lim = 1, L = 0;
	while(lim <= (n << 1))	lim <<= 1, L++;
	for(int i = 0; i < lim; i++)	
		rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (L - 1));
	FFT(a, lim,1), FFT(b, lim, 1),FFT(c, lim, 1);
	for(int i = 0; i < lim; i++)	
		a[i] = a[i] * b[i], c[i] = c[i] * b[i];
	FFT(a, lim, -1), FFT(c, lim, -1);
	for(int i = 1; i <= n; i++)
		printf("%.3lf\n", a[i].x - c[n - i].x);
	return 0;
}
[AH2017/HNOI2017]礼物

题意：数组 a i a_{i} ai​、 b i b_{i} bi​，可以对 a i a_{i} ai​整体加一个正整数，也可以对 b i b_{i} bi​整体加一个正整数，然后进行轮转，求 ∑ i = 1 n ( a i − b i ) 2 \sum_{i=1}^{n}(a_{i}-b_{i})^{2} ∑i=1n​(ai​−bi​)2 的最小值。
思路：
  整体加值的操作可以看出在其中一个数组上进行加减，于是所求值可以写成 ∑ i = 1 n ( a i + x − b i ) 2 = ∑ i = 1 n a i 2 + ∑ i = 1 n b i 2 + n x 2 + 2 x ∑ i = 1 n a i − 2 x ∑ i = 1 2 b i − 2 ∑ i = 1 n a i b i \sum_{ i=1}^{n}(a_{i}+x-b_{i})^{2}=\sum_{i=1}^{n}a_{i}^{2}+\sum_{i=1}^{n}b_{i}^{2}+nx^{2}+2x\sum_{i=1}^{n}a_{i}-2x\sum_{i=1}^{2}b_{i}-2\sum_{i=1}^{n}a_{i}b_{i} i=1∑n​(ai​+x−bi​)2=i=1∑n​ai2​+i=1∑n​bi2​+nx2+2xi=1∑n​ai​−2xi=1∑2​bi​−2i=1∑n​ai​bi​。发现只需求 n x 2 − 2 ∑ i = 1 n a i b i nx^{2}-2\sum_{i=1}^{n}a_{i}b_{i} nx2−2∑i=1n​ai​bi​的最小值就可以了，而 n x 2 nx^{2} nx2与 2 ∑ i = 1 n a i b i 2\sum_{i=1}^{n}a_{i}b_{i} 2∑i=1n​ai​bi​两项的变化没有关系，可以分开来看。
  对于 ∑ i = 1 n a i b i \sum_{i=1}^{n}a_{i}b_{i} ∑i=1n​ai​bi​，翻转 a i a_{i} ai​得到 ∑ i = 1 n a n − i b i \sum_{i=1}^{n}a_{n-i}b_{i} ∑i=1n​an−i​bi​，倍长 b i b_{i} bi​以后FFT，求 x n x^{n} xn项以后最小的即可。
  对于 n x 2 nx^{2} nx2，枚举[-m, m]中每一个值就可以了。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long LL;
const int N = 4e5 + 10;
const double PI = acos(-1.0);
struct Complex{
	double x, y;
	Complex (){}
	Complex (double u, double v){	x = u, y = v;}
	Complex operator + (const Complex & other) const{ return Complex (x + other.x, y + other.y);}
	Complex operator - (const Complex & other) const{ return Complex (x - other.x, y - other.y);}
	Complex operator * (const Complex & other) const{ return Complex(x * other.x - y * other.y, x * other.y + y * other.x);}
	
}A[N], B[N];
int rev[N];
int FFT_pre(int n)
{
	int lim = 1, L = 0;
	while(lim <= n)	lim <<= 1, L++;
	for(int i = 0; i < lim; i++)	
		rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (L - 1));
	return lim;
}
void FFT(Complex a[], int lim, int opt)
{
	for(int i = 0; i < lim; i++)
		if(i < rev[i])
			swap(a[i], a[rev[i]]);
	for(int i = 2; i <= lim; i <<= 1)
	{
		int tmp = i >> 1;
		Complex wn = Complex(cos(2 * PI / i), opt * sin(2 * PI / i));
		for(int j = 0; j < lim; j += i)
		{
			Complex w = Complex(1.0, 0.0);
			for(int k = 0; k < tmp; k++)
			{
				Complex tmp1 = a[j + k];
				Complex tmp2 = w * a[j + k + tmp];
				a[j + k] = tmp1 + tmp2;
				a[j + k + tmp] = tmp1 - tmp2;
				w = w *wn;
			}
		}
	}
	if(opt == -1)
		for(int i = 0; i < lim; i++)
			a[i].x /= lim;
}
int a[N], b[N];
int main()
{
	int n, m;
	scanf("%d%d", &n, &m);
	for(int i = 1;i <= n; i++)	scanf("%d", &a[i]);
	for(int i = 1; i <= n; i++)	scanf("%d", &b[i]);
	LL sum1 = 0, sum2 = 0;
	for(int i = 1; i <= n; i++)
	{
		A[n - i + 1].x = a[i];
		B[i].x = B[i + n].x = b[i];
		sum1 += a[i] * a[i] + b[i] * b[i];
		sum2 += a[i] - b[i];
	}
	int lim = FFT_pre(n * 3);
	FFT(A, lim, 1);
	FFT(B, lim, 1);
	for(int i = 0; i < lim; i++)	A[i] = A[i] * B[i];
	FFT(A, lim, -1);
	LL ans = 1e18;
	for(int i = 1; i <= n; i++)
		for(int j = -m; j <= m; j++)
			ans = min(ans, sum1 + 2 * j * sum2 + n * j * j - 2 * (LL)(A[i + n].x + 0.5));
	cout << ans;
	return 0; 
 }
selia1078
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#中实现FFT的两种方法
zhoudapeng01的专栏
12-24 9564
最近工作中有个需求，在C#环境中实现FFT算法，在网上找了些资料，最后实现了下面的两种方式，实际应用任选其一就好。 第一种方法： 不依赖C#中的Complex，需要实现计算过程的每一步详细步骤。 输入序列长度为2的N次幂，使用前需先定义序列长度： FFT filter = new FFT(256); filter.fft(x,y) 其中x为实部y为虚部，计算后x为FFT后的实部，y为FF...
傅立叶变换的C#实现
03-31
快速傅立叶变换，使用C#实现。在一个.cs文件里。直接拿来用就行了。很方便。
fjut 3283 - FFT多项式乘法
过路人丶的博客
05-22 205
题目链接：点击打开链接本题简单剖析出来就是固定其中一个串然后另一个串旋转到一个位置值得答案值最大.我们发现每次求值的复杂度是O(n),一共有n种旋转方法，所以总复杂度是O(n^2),如果把这n种都综合起来的话不就是近似多项式乘法了吗？那么怎么转换呢？看下面的图以n=5为例,那么5种旋转方式的值分部在多项式的哪里呢？从图看出就是x^4,x^3和x^8，x^2和x^7，x^1和x^6,1和x^5.总结...
python np fft_麦克风阵列信号测试：相位测试（python）
weixin_39897267的博客
11-27 705
对于麦克风阵列来讲，N个麦克风之间信号是否有延迟，可以通过N个数据之间的相位差来判断。相位差是判断麦克风信号同步性的重要指标之一。1. 相位和相位差首先解释一下什么是相位和相位差。1.1 相位相位(phase) 是对于一个波，特定的时刻在它循环中的位置：一种它是否在波峰、波谷或它们之间的某点的标度。相位描述信号波形变化的度量，通常以度(角度)作为单位，也称作相角。当信号波形以周期的方式变...
fftw的使用
Be busy living or busy dying
04-18 7788
文章目录获取方法功能介绍程序使用方法步骤1：下载问题1：为什么dll文件要区分32bit还是64bit？问题2：为什么lib文件需要自己生成？问题3：def文件是什么？步骤2：生成lib导入库文件配置库文件编程使用参考链接 获取方法 FFTW首页：http://www.fftw.org/ 据说FFTW是世界上最快的FFT。 下载地址：http://www.fftw.org/download.htm...
数字信号处理-快速傅里叶变换FFT实验报告
05-06
【快速傅里叶变换FFT】是一种高效的离散傅里叶变换计算方法，广泛应用于数字信号处理领域。在西安交通大学的这个实验中，学生通过实践深入理解了FFT算法及其在信号频谱分析中的应用。 实验的目的在于使学生： 1. ...
详解快速傅里叶变换FFT算法
06-25
快速傅里叶变换（Fast Fourier Transform，简称FFT）是一种高效的计算离散傅里叶变换（Discrete Fourier Transform，DFT）的方法，对于处理信号分析、图像处理、通信工程等领域的问题有着广泛的应用。本文将深入探讨...
快速傅里叶变换FFT的C语言实现及应用_fft_快速傅里叶变换_
09-29
快速傅里叶变换（FFT，Fast Fourier Transform）是数字信号处理领域中的一种高效算法，用于计算离散傅里叶变换（DFT）及其逆变换。它由数学家库利（John W. Cooley）和图基（James W. Tukey）在1965年提出，极大地...
实验4 快速傅立叶变换(FFT).doc
07-06
快速傅立叶变换（FFT）是数字信号处理领域中一种至关重要的算法，它极大地提高了离散傅立叶变换（DFT）的计算效率。DFT是连续傅立叶变换在离散时间序列上的应用，然而，由于DFT的计算复杂度为O(N^2)，对于大数据量的...
Matlab 快速傅里叶变换FFT代码
03-26
Matlab 快速傅里叶变换FFT代码。信号处理 注释详细，保证能运行。 时域图像，频域图像，双边谱，单边谱。 有一份数据，方便查看数据样式！！！！！！！！！！！！！！！！ 按照数据样式编辑你的数据，更换后即可运行...
信号处理 快速傅里叶变换 FFT
最新发布
08-14
快速傅里叶变换 (Fast Fourier Transform)，即利用计算机计算离散傅里叶变换（DFT）的高效、快速计算方法的统称，简称FFT，于1965年由J.W.库利和T.W.图基提出。 是对离散傅里叶变换的快速算法！
自己编写的二维快速傅里叶变换fft程序 matlab平台
01-14
没有调用matlab自带的fft函数，而是自己编写的二维快速傅里叶变换fft程序 matlab平台 没有调用matlab自带的fft函数，而是自己编写的二维快速傅里叶变换fft程序 matlab平台
快速傅立叶变换FFT频谱分析程序.pdf
01-11
快速傅立叶变换FFT频谱分析程序.pdf
快速傅里叶变换 fft C语言实现
02-02
快速傅里叶变换（FFT，Fast Fourier Transform）是一种在数字信号处理领域中极其重要的算法，它用于计算离散傅里叶变换（DFT）及其逆变换。在C语言中实现FFT，可以为各种应用场景提供高效的计算能力，比如音频处理、...
vb实现快速傅里叶变换fft
07-29
### vb实现快速傅里叶变换FFT 在计算机科学与信号处理领域中，快速傅里叶变换（Fast Fourier Transform，简称FFT）是一种高效的离散傅里叶变换（Discrete Fourier Transform，DFT）算法，用于计算复数序列的离散...
FFT—快速傅里叶变换算法——STM32F1+自定义C语言库（3）
qq_27762895的博客
11-29 8023
C语言版FFT简单测试 本次我们来自己封装一个FFT函数，进行简单的测试。 fft.c #include "math.h" #include "fft.h" //精度0.0001弧度 //复数的交换 void conjugate_complex(int n,complex in[],complex out[]) { int i = 0; for(i=0;i<n;i++) ...
C语言实现FFT和IFFT，并与MATLAB编写显示的结果相对比，进行验证（蝶形运算）
Xie_01的博客
12-07 2359
本次实验中在Microsoft Visual Studio 2010环境下编写，实现FFT和IFFT，并用MATLAB编写显示的结果，两者相对比，进行验证。 #include “stdafx.h” #include #include<math.h> #include const double pi=3.14159265357; #include using namespace std...
手把手教系列之快速傅立叶算法
嵌入式客栈
06-18 2116
关注、星标嵌入式客栈，精彩及时送达[导读] 由于原来公众号是今年申请的，没有留言功能，不方便及时交流。比如小号里的文章由于水平所限，有时候有错误，小伙伴们没有办法及时帮忙指正交流。前面一...
快速傅里叶变换（FFT）的C#实现及详细注释
热门推荐
随煜而安的专栏
07-21 3万+
快速傅里叶变换（FFT）的C#实现及详细注释 ------------------------------------------------------------------------------------------------------------------- 作者：随煜而安 时间：2015/7/21 注：本文为作者原创文章，所有参考内容均在参考文献中列出，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值