FFT(Fast Fourier Transform,快速傅里叶)

FFT(Fast Fourier Transform,快速傅里叶)

DFT(Discrete Fourier Transform，离散傅里叶变换)是傅里叶变换在时域和频域上都呈离散的形式，而FFT，则是将DFT快速实现的一种方式，在计算机系统、数字系统中有重要作用，显著降低了运算的复杂性。

概念介绍

Convolution

卷积 (Convolution)，说是一种通过两个函数(f · g) 生成第三个函数的一种数学算子.

更具一般性，卷积定义为：
$$h(x)={\int }_{-\infty }^{\infty }g(\tau )f(x-\tau )d\tau$$
形如这个式子，由$g(\tau )$ 与 $f(x-\tau )$ 形成的 $h(x)$ 就被称为 卷积

这个定义可以拓展到多项式域：
$$A(x)\cdot B(x)=\sum _{i=0}^n\sum _{j=0}^i{a}_j{b}_{i-j}$$
其中，$A(x)$ 和 $B(x)$ 均为 $n$ 次多项式

对这个多项式域的卷积合并同类项，最后可以得到 $2n+1$ 项

Dot Method

点表示法(Dot Method)，是另外一种描述多项式的形式，更一般的，我们遇到的多项式都是采用 系数表示法，也就是下面的形式:
$$f(x)=a_0+a_{1}x+a_2{x}^2+a_3{x}^3+...+a_n{x}^n\iff f(x)=\{a_0,a_1,a_2...a_n\}$$
而对于点值表示法来说，我们就不是选取多项式的系数来表示这个多项式，而是在这个多项式所描述的图像（曲线）上选择一些点，来描述这个多项式。

其思想为：对于一个 $n$ 次多项式，我们选择 $n+1$ 个点，只要这些点不重复（指点互相不呈现倍数关系）,那么这 $n+1$ 个点就能唯一确定一个多项式。

Proof

借助高斯消元的思想：两点确定直线，每多一个点，就可以多确定曲线的一个参数，那么$n+1$ 个点就能确定 $n$ 个参数。

因此，我们将多项式视为一个函数，采用点值表示法描述如下：
$$\begin{gathered} f(x_k)\iff a_0+a_1{x}_k+a_2{x}_k^2+...+a_n{x}_k^n,0\le k\le n \\ f(x)=a_0+a_{1}x+a_2{x}^2+...+a_n{x}^n\iff f(x)=\{(x_0,y_0),(x_1,y_1)...(x_n,y_n)\} \end{gathered}$$
将其转换为多项式描述法，即设 $F(x)=f(x)\cdot g(x)$就有:
$$\begin{gathered} f(x)=\{(x_0,f(x_0)),(x_1,f(x_1))...(x_n,f(x_n))\} \\ g(x)=\{(x_0,g(x_0)),(x_1,g(x_1))...(x_n,g(x_n))\} \\ F(x)=\{(x_0,f(x_0)g(x_0)),(x_1,f(x_1)g(x_1))...(x_n,f(x_n)g(x_n))\} \end{gathered}$$
经过以上过程，我们就成功将一个多项式，从系数表达式转变为了点表达式，这一过程又称 $DFT$

小总结

接下来让我们回忆一下到目前为止我们对多项式的讨论：

我们把一个 $n$ 阶的多项式视为一个函数，在其中选取了 $n+1$ 个点，来描述这个多项式。

考虑一个朴素的做法：

—选取 $n+1$ 个点，我们需要 $\Theta (n^2)$ 时间

—点乘法，对于 $n$ 阶多项式而言，我们需要 $\Theta (n)$

—将点值映射回系数表达式，至少需要 $\Theta (n^2)$ 的时间

看起来更麻烦了，比朴素的乘法常数还要高，难道真的没有办法了吗？

这时候就是 $FFT$ 出场的时候了， $FFT$ 可以使得对于第一个选点和第三个将点映射回系数的操作从$\Theta (n^2)$ 变为 $\Theta (nlogn)$

本质上, FFT 包含 DFT （离散傅立叶变换）和 IDFT （逆离散傅立叶变换）实际上， DFT 对应着的就是把系数表达式映射到点值表达式的过程， IDFT 对应着的就是我们把点值表达式映射到系数表达式的过程。

下面我们来讨论这个优化的过程。

Complex

首先我们假设有一个复数 $w$ 其满足 $w^n=1$，易知其解 $w$ 有 $n$ 个，并且这 $n$ 个解都满足 $w$ 在复数平面上的模长都是 1 。根据复数平面的知识，两个复数相乘，等于其在复数平面上的向量模长相乘，幅角相加，因此这 $n$ 个解我们可以理解为复数平面的 $n$ 个单位向量，并且他们的幅角之和为360°，也就是把复数平面内的单位元 $n$ 等分的 $n$ 个向量。

考虑欧拉公式
$$e^{ix}=cosx+isinx$$
当x = 2π时，得:
$$e^{2\pi i}=1=w^n\iff w=e^{\frac{2\pi i}{n}}$$
由此我们得到了这 $n$ 个解的表示，其称为 主次单位根，记为:
$$w_n=e^{\frac{2\pi i}{n}}$$
单位根具有如下性质:
$$\begin{gathered} w_n^n=1 \\ {w}_{dn}^{dk}=w_n^k,n\ge 0,k\ge 0,d>0 \\ (w_n^k{)}^2=(w_n^{2k})=(w_{\frac{n}{2}}^k) \\ {w}_{2n}^{k+n}=-w_{2n}^k \end{gathered}$$
介绍完单位复根的性质后，我们可以进入 $FFT$的环节了。

FFT核心 ：分治

DFT的分治

FFT采用了分治法来求取每一个 $x=w_n^k$ 时的值，分治的关键在于将多项式化为奇函数与偶函数进行处理。

下面是一个对7阶多项式分治的例子：
$$\begin{gathered} f(x)=a_0+a_{1}x+a_2{x}^2+a_3{x}^3+a_4{x}^4+a_5{x}^5+a_6{x}^6+a_7{x}^7 \\ f(x)=(a_0+a_2{x}^2+a_4{x}^4+a_6{x}^6)+(a_1{x}^1+a_3{x}^3+a_5{x}^5+a_7{x}^7) \\ f(x)=(a_0+a_2{x}^2+a_4{x}^4+a_6{x}^6)+x(a_1+a_3{x}^2+a_5{x}^4+a_7{x}^6) \end{gathered}$$
接下来构造两个新函数:
$$\begin{gathered} g(x)=(a_0+a_{2}x+a_4{x}^2+a_6{x}^3) \\ h(x)=(a_1+a_{3}x+a_5{x}^2+a_7{x}^3) \\ f(x)=g(x^2)+x\cdot h(x^2) \end{gathered}$$
由于每一个x都是单位复根，可以带入单位复根的性质:
$$\begin{array}{rl}f(w_n^k)=& g((w_n^k{)}^2)+w_n^k\cdot h((w_n^k{)}^2)\\ =& g(w_n^{2k})+w_n^k\cdot h(w_n^{2k})\\ =& g(w_{\frac{n}{2}}^k)+w_n^k\cdot h(w_{\frac{n}{2}}^k)\end{array}$$
类似有:
$$\begin{array}{rl}f(w_n^{k+\frac{n}{2}})=& g(w_n^{2k+n})+w_n^{k+\frac{n}{2}}\cdot h(w_n^{2k+n})\\ =& g(w_n^{2k})-w_n^k\cdot h(w_n^{2k})\\ =& g(w_{\frac{n}{2}}^k)-w_n^k\cdot h(w_{\frac{n}{2}}^k)\end{array}$$
因此我们只要求得 $g(w_{\frac{n}{2}}^k)$ 和 $h(w_{\frac{n}{2}}^k)$ 就可以求出 $f(w_n^k)$ 和 $f(w_n^{k+\frac{n}{2}})$ 也就是可以递归求解。

需要注意分治处理的时候的多项式长度必须是2的整数次幂，因此需要补0，最高次项为 $2^{m-1}$的形式。

由此可以总结出DFT变换的代码模板:

#include 
#include 
typedef std::complex<double> complex;
const double PI = acos(-1.0);
const int MAX_N = 1 << 20;

complex tmp[MAX_N];

void DFT(complex* f, int n, int rev) {  // rev=1,DFT; rev=-1,IDFT
	if (n == 1) return;
	for (int i = 0; i < n; ++i) tmp[i] = f[i];
	for (int i = 0; i < n; ++i) {  // 偶数放左边，奇数放右边
		if (i & 1)
			f[n / 2 + i / 2] = tmp[i];
		else
			f[i / 2] = tmp[i];
	}
	complex* g = f, * h = f + n / 2;
	DFT(g, n / 2, rev), DFT(h, n / 2, rev);  // 递归 DFT
	complex cur(1, 0), step(cos(2 * PI / n), sin(2 * PI * rev / n));
	// Comp step=exp(I*(2*PI/n*rev)); // 两个 step 定义是等价的
	for (int k = 0; k < n / 2; ++k) {
		tmp[k] = g[k] + cur * h[k];
		tmp[k + n / 2] = g[k] - cur * h[k];
		cur *= step;
	}
	for (int i = 0; i < n; ++i) f[i] = tmp[i];
}

逆序位置换/蝴蝶变换(bit-reversal permutation)

可以看到我们在上面的DFT变换中多次对当前的多项式的奇偶次幂进行划分，而这个过程是可以被预处理的，而递归的过程也需要非常大的内存，所以我们采取了一种"模仿递归"的操作，对原数组进行“拆分”与“合并”。

我们采取从小到大循环的方式，当我们循环到 $R(x)$ 时，$R(\lfloor \frac{x}{2}\rfloor )$ 是已知的，观察后可以发现，除了最高位， $R(x)$ 剩余的位数都是由$R(\lfloor \frac{x}{2}\rfloor )$ 右移一位得来。

对于最高位，我们只要检查 $x$ 本身是否为 $1$ ，如果是，对 $R(x)$ 加上 $\frac{len}{2}$ 即可。

即:
$$R(x)=\lfloor R(\lfloor \frac{x}{2}\rfloor )\rfloor +(xmod2)\cdot \frac{len}{2}$$
代码实现如下:

// 同样需要保证 len 是 2 的幂
// 记 rev[i] 为 i 翻转后的值
void change(Complex y[], int len) {
  for (int i = 0; i < len; i++) {
    rev[i] = rev[i >> 1] >> 1;
    if (i & 1) {  // 如果最后一位是 1，则翻转成 len/2
      rev[i] |= len >> 1;
    }
  }
  for (int i = 0; i < len; i++) {
    if (i < rev[i]) {  // 保证每对数只翻转一次
      swap(y[i], y[rev[i]]);
    }
  }
  return;
}

快速傅里叶逆变换

前面介绍了DFT，其作用为将系数表示法转换为点表示法，现在我们有了点，还需要将其转换为系数，这就是IDFT。

经过了前面一长串的变化，我们求出了这个线性方程组左边的值，现在我们采用线性方程组的思想来考虑这个问题，给了我们方程组的向量，以及系数矩阵，如何求出方程组的解？很简单，只要我们左乘矩阵的逆即可。

观察这个矩阵，不难发现这是一个范德蒙方阵，在数学上可以证明其逆矩阵非常特殊，其每一项元素都是原矩阵的倒数再乘以 $\frac{1}{n}$

此时我们结合欧拉公式，有一个惊人的发现:
$$\frac{1}{w_n}=w_n^{-1}=e^{-\frac{2\pi i}{n}}=cos(\frac{2\pi }{n})+isin(-\frac{2\pi }{n})$$
也就是说，我们只要再跑一遍对DFT的算法，只不过多乘一个 $-1$ 的系数，就可以将我们得到的点再转变为系数。

如下是模仿递归的代码:

/*
 * 做 FFT
 * len 必须是 2^k 形式
 * on == 1 时是 DFT，on == -1 时是 IDFT
 */
void fft(Complex y[], int len, int on) {
  change(y, len);
  for (int h = 2; h <= len; h <<= 1) {                  // 模拟合并过程
    Complex wn(cos(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;
        // 后半个 “step” 中的ω一定和 “前半个” 中的成相反数
        // “红圈”上的点转一整圈“转回来”，转半圈正好转成相反数
        // 一个数相反数的平方与这个数自身的平方相等
        w = w * wn;
      }
    }
  }
  if (on == -1) {
    for (int i = 0; i < len; i++) {
      y[i].x /= len;
    }
  }
}

完整实现:

#include 
#include 
#include 
using namespace std;

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);
    }
};
const double PI = acos(-1.0);
const int MAXN = 200020;
complex x1[MAXN], x2[MAXN];
char str1[MAXN / 2], str2[MAXN / 2];
int sum[MAXN],rev[MAXN];
// 同样需要保证 len 是 2 的幂
// 记 rev[i] 为 i 翻转后的值
void change(complex y[], int len) {
    for (int i = 0; i < len; i++) {
        rev[i] = rev[i >> 1] >> 1;
        if (i & 1) {  // 如果最后一位是 1，则翻转成 len/2
            rev[i] |= len >> 1;
        }
    }
    for (int i = 0; i < len; i++) {
        if (i < rev[i]) {  // 保证每对数只翻转一次
            swap(y[i], y[rev[i]]);
        }
    }
    return;
}
/*
 * 做 FFT
 * len 必须是 2^k 形式
 * on == 1 时是 DFT，on == -1 时是 IDFT
 */
void fft(complex y[], int len, int on) {
    change(y, len);
    for (int h = 2; h <= len; h <<= 1) {                  // 模拟合并过程
        complex wn(cos(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;
                // 后半个 “step” 中的ω一定和 “前半个” 中的成相反数
                // “红圈”上的点转一整圈“转回来”，转半圈正好转成相反数
                // 一个数相反数的平方与这个数自身的平方相等
                w = w * wn;
            }
        }
    }
    if (on == -1) {
        for (int i = 0; i < len; i++) {
            y[i].x /= len;
        }
    }
}


int main() {
    while (scanf("%s%s", str1, str2) == 2) {
        int len1 = strlen(str1);
        int len2 = strlen(str2);
        int len = 1;
        while (len < len1 * 2 || len < len2 * 2) len *= 2;
        for (int i = 0; i < len1; i++) x1[i] = complex(str1[len1 - 1 - i] - '0', 0);
        for (int i = len1; i < len; i++) x1[i] = complex(0, 0);
        for (int i = 0; i < len2; i++) x2[i] = complex(str2[len2 - 1 - i] - '0', 0);
        for (int i = len2; i < len; i++) x2[i] = complex(0, 0);
        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++) sum[i] = int(x1[i].x + 0.5);
        for (int i = 0; i < len; i++) {
            sum[i + 1] += sum[i] / 10;
            sum[i] %= 10;
        }
        len = len1 + len2 - 1;
        while (sum[len] == 0 && len > 0) len--;
        for (int i = len; i >= 0; i--) printf("%c", sum[i] + '0');
        printf("\n");
    }
    return 0;
}

代码部分参考各个大佬的算法模板，这里主要记录第一次学习时的思路。