FFT算法实践

快速傅里叶变换（FFT）

使用范围：多项式相乘。

傅里叶变换及逆变换

1、多项式的点表示
A(x)=a₀+a₁*x+a₂*x²+…+a_la-1*x^la-1(共la项）
先代入la个x值得到la个A（x）值，用la个点<x_i,A_i>(i=0、1…la-1)表示
知道这些点就能反解出A的各项系数即可用这la个点表示多项式A

2、多项式乘法的点表示
C(x)=A(x)*B(x)
<x_i,A(x_i)>属于A
<x_i,B(x_i)>属于B(这里的x_i与A的是同一个)
则易得<x_i,A(x_i)*B(x_i)>属于C，所以只要有>=C中系数数量的点就能解得C的所有系数

3、傅里叶变换的思想
代入n个x把A、B都转换成点//称为离散傅里叶变换
再得到C的点<x_i,C_i>这里的x使用复数
最后用C上的点得到C的所有系数。//称为傅里叶逆变换

4、傅里叶变换的数学准备

傅里叶要用到的n个复数，不是随机找的，而是——把单位圆（圆心为原点、1为半径的圆）n等分，取这n个点（或点表示的向量）所表示的虚数，即分别以这n个点的横坐标为实部、纵坐标为虚部，所构成的虚数。

从点(1,0)开始（显然这个点是我们要取的点之一），逆时针将这n个点从0开始编号，第k个点对应的虚数记作ωkn（根据复数相乘时模长相乘幅角相加可以看出，ωkn是ω1n的k次方，所以ω1n被称为n次单位根）。
根据每个复数的幅角，可以计算出所对应的点/向量。ω^k_n对应的点/向量是
e^ik*2π/n
单位根的性质:
性质一：ω^2k_2n=ω^k_n
性质二：ω^k+n_2n=−ω^k_n
摘自：https://www.cnblogs.com/RabbitHu/p/FFT.html

5、傅里叶变换证明
其核心就是单位根及其共轭的运用
令(y₀,y₁,…,y_n−1) 为多项式A(x)=a₀+a₁x+…+a_nxⁿ⁻¹代入n个单位根后的n个值。
设一个多项式T(x)=y₀+y₁x+…+y_n−1xⁿ⁻¹，现在我们把上面的n个单位根的倒数，即ω⁰_n,ω⁻¹_n,…,ω⁻⁽ⁿ⁻¹⁾_n作为x代入T(x), 同样得到n个值(z₀,z₁,…,z_n−1)。

当j−k=0的部分的值等于n; 其它情况，等比数列求和可知它等于0
所以z_k就等于n*a_k
相当于又来了一次离散傅里叶变换
6、快速傅里叶变换的理论
终于到正题了。。。
A(x)=a₀+a₁x+…+a_nxⁿ⁻¹
首先将A(x)的每一项按照下标的奇偶分成两部分：
A(x)=(a₀+a₂x²+…+a_n−2xⁿ⁻²)+(a₁x+a₃x³+…+a_n−1xⁿ⁻¹)
设两个多项式：
A1(x)=a₀+a₂x+…+a_n−2x^n/2−1
A2(x)=a₁+a₃x+…+a_n−1x^n/2−1
可得：
A(x)=A1(x²)+xA2(x²)
假设k<n/2，将x=ω^k_n代入：
A(ω^k_n)=A1(ω^2k_n)+ω^k_nA2(ω^2k_n)=A1(ω^k_n/2)+ω^k_nA2(ω^k_n/2)
对于A(ω^k+n/2_n)：
A(ω^k+n/2_n)=A1(ω^2k+n_n)+ω^k+n/2_nA2(ω^2k+n_n)=A1(ω^k_n/2×ωⁿ_n)+ω^k+n/2_nA2(ω^k_n/2×ωⁿ_n)=A1(ω^k_n/2)−ω^k_nA2(ω^k_n/2)
一眼下去肯定是分治递归，但那样肯定数据爆炸递归往往是这样 ，但我们还有动规，应该从底层（分到每项只有一个元素）向上递推，具体实现如下。

编程实现

1、多项式的预处理
A(x)=a₀+a₁*x+a₂*x²+…+a_la-1*x^la-1(共la项）
B(x)=b₀+b₁*x+b₂*x²+…+b_lb-1*x^lb-1(共lb项)
C(x)=A(x)*B(x)=c₀+c₁*x+c₂*x²+…+c_lc-1*x^lc-1(lc<=la * lb)
要使用FFT首先得将la、lb补至n（n=2^k，n>=lc)，x^la-1，x^lb-1之后的项用0系数填。
*为了有足够数量的<x,C(x)>来解得C的所有系数，一定要n>=lc。
A(x)=a₀+a₁*x+a₂*x²+…+a_n-1*x^n-1
B(x)=b₀+b₁*x+b₂*x²+…+b_n-1*x^n-1

    cin >> stra;
	cin >> strb;
	lena = strlen(stra);
	lenb = strlen(strb);
	while (n < lena + lenb)
		n *= 2;

2、求解单位根
预处理从w⁰_n至w^n-1_n的n个单位根及其共轭

void init(cp*omg,cp*inv,int n) {
	for (int i = 0; i < n; ++i) {
		omg[i] = cp(cos(2 * pi * i / n), sin(2 * pi * i / n));
		inv[i] = ~omg[i];
	}
}

3、处理递推底层系数
先通过递归图像分析：
如果a的下标能被2整除，则排在左侧否则在右侧。
如果a的下标能被4整除，则排在左侧的左侧。
如果a的下标能被2整除不能能被4整除，则排在左侧的右侧。
。
。
。
故a的位置与其下标的二进制表示有关。

在A中的排列{a₀,a₁,…,a_n-1}，a_i最后的位置的二进制表示是i的二进制表示的对称数（如：n=8，3=011B，a₃排在6=110B处）

int lim = 0;
	while ((1 << lim) < n)++lim;//计算二分了几层
	for (int i = 0; i < n; ++i) {
		int t = 0;
		for (int j = 0; j < lim; ++j)
			if ((i >> j) & 1)//比较二进制表示每一位是否为1
				t |= (1 << (lim - j - 1));//下标二进制的相反
		if (i < t) {//因为两个二进制数互为相反，进行交换位置
		            //i<t主要为了防止交换两次
			cp temp;
			temp = p[i];
			p[i] = p[t];
			p[t] = temp;
		}
	}

4、迭代求解A(w^k_n)
数组上的迭代关系如图所示：

可以用三重循环解得

for (int l = 2; l <= n; l *= 2) {//迭代重数
		int m = l / 2;//二分后单个新数组的数据数量
		for (int j=0;j<n;j+=l)
			for (int i = 0; i < m; i++) {//已使用蝴蝶变换优化
				cp t = omg[n / l * i] * p[j+i + m];
				p[j+i + m] = p[j+i] - t;
				p[j+i] = p[j+i]+t;
			}
	}

5、完整FFT

void init(cp*omg,cp*inv,int n) {
	for (int i = 0; i < n; ++i) {
		omg[i] = cp(cos(2 * pi * i / n), sin(2 * pi * i / n));
		inv[i] = ~omg[i];
	}
}

void FFT(cp* p, cp* omg,int n) {
	int lim = 0;
	while ((1 << lim) < n)++lim;
	for (int i = 0; i < n; ++i) {
		int t = 0;
		for (int j = 0; j < lim; ++j)
			if ((i >> j) & 1)
				t |= (1 << (lim - j - 1));
		if (i < t) {
			cp temp;
			temp = p[i];
			p[i] = p[t];
			p[t] = temp;
		}
	}
	for (int l = 2; l <= n; l *= 2) {
		int m = l / 2;
		for (int j=0;j<n;j+=l)
			for (int i = 0; i < m; i++) {
				cp t = omg[n / l * i] * p[j+i + m];
				p[j+i + m] = p[j+i] - t;
				p[j+i] = p[j+i]+t;
			}
	}
}

5、编程要点
在编程中一定会用到复数计算，c++自带的complex库有点慢，推荐自己建。
三重for里的for (int j=0;j<n;j+=l)很容易忘记j+=l。。。我健忘
在处理通过FFT得到的数据时下列处理方法不错（别忘记逆变换后要除n）

floor(a[i].real() / n + 0.5);

6、附上FFT加速的高精度乘法

#include <iostream>
#include<cmath>
#include<cstring>
const double pi = 3.1415926;
using namespace std;
class complex {
private:
	double x, y;
public:
	complex() {
		x = y = 0;
	}
	complex(double a, double b) {
		x = a;
		y = b;
	}
	double real(void) {
		return x;
	}
	void real(double a) {
		x = a;
	}
	complex operator +(const complex& a) {
		complex result;
		result.x = this->x + a.x;
		result.y = this->y + a.y;
		return result;
	}
	complex operator -(const complex& a) {
		complex result;
		result.x = this->x - a.x;
		result.y = this->y - a.y;
		return result;
	}
	complex operator *(const complex& a) {
		complex result;
		result.x = (this->x) * a.x - (this->y) * a.y;
		result.y = (this->x) * a.y + (this->y) * a.x;
		return result;
	}
	friend complex operator  ~ (const complex& a);
};
complex operator  ~ (const complex& a) {
	complex result;
	result.x = a.x;
	result.y = -a.y;
	return result;
}
typedef complex cp;



void init(cp*omg,cp*inv,int n) {
	for (int i = 0; i < n; ++i) {
		omg[i] = cp(cos(2 * pi * i / n), sin(2 * pi * i / n));
		inv[i] = ~omg[i];
	}
}

void FFT(cp* p, cp* omg,int n) {
	int lim = 0;
	while ((1 << lim) < n)++lim;
	for (int i = 0; i < n; ++i) {
		int t = 0;
		for (int j = 0; j < lim; ++j)
			if ((i >> j) & 1)
				t |= (1 << (lim - j - 1));
		if (i < t) {
			cp temp;
			temp = p[i];
			p[i] = p[t];
			p[t] = temp;
		}
	}
	for (int l = 2; l <= n; l *= 2) {
		int m = l / 2;
		for (int j=0;j<n;j+=l)
			for (int i = 0; i < m; i++) {
				cp t = omg[n / l * i] * p[j+i + m];
				p[j+i + m] = p[j+i] - t;
				p[j+i] = p[j+i]+t;
			}
	}
}

int len1, len2, n = 1;
int res[10005] = {};
cp a[10005], b[10005];
cp omg[10005], inv[10005];
char sa[10005], sb[10005];

int main()
{	

	cin >> sa;
	cin >> sb;
	len1 = strlen(sa);
	len2 = strlen(sb);
	while (n < len1 + len2)n *= 2;
	for(int i=0;i<len1;++i)
		a[i].real(sa[len1 - 1 - i] - '0');
	for(int i=0;i<len2;++i)
		b[i].real(sb[len2 - 1 - i] - '0');
	init(omg,inv,n);
	FFT(a, omg,n);
	FFT(b, omg,n);
	for (int i = 0; i < n; ++i)
		a[i] = b[i]*a[i];
	FFT(a, inv,n);
	for (int i = 0; i < n; i++) {
		res[i] += floor(a[i].real() / n + 0.5);
		res[i + 1] += res[i] / 10;
		res[i] %= 10;
	}
	if (res[len1 + len2 - 1] == 0)
		--len1;
	for (int i = len1 + len2 - 1; i >= 0; i--)
		printf("%d", res[i]);
}