初涉傅里叶变换

---

傅里叶变换

^{Fourier transform}

---

  傅里叶变换（法语：Transformation de Fourier、英语：Fourier transform）是一种线性积分变换，用于信号在时域（或空域）和频域之间的变换，在物理学和工程学中有许多应用。

  摘自 wiki 百科

  简单来说，$\mathrm{F}\mathrm{T}$ 就是在某个域内将给定的信号映射到振幅，但此文意在简述信奥赛中，$\mathrm{F}\mathrm{F}\mathrm{T}$ 的推导过程以及应用，故简单以此开头，不做更深入的解释。

---

离散傅里叶变换

^{Discrete Fourier transform}

---

  离散傅里叶变换（Discrete Fourier transform，缩写为 DFT），是傅里叶变换在时域和频域上都呈离散的形式，将信号的时域采样变换为其 DTFT 的频域采样。

  摘自 wiki 百科

  定义序列 $x=\{x_i|i=0,1,2,\cdots ,N-1\}$，定义它的 $\mathrm{D}\mathrm{F}\mathrm{T}$ 为 $\hat{x}=\{{\hat{x}}_i\}$$${\hat{x}}_k=\sum _{n=1}^{N-1}{e}^{-i\frac{2\pi }{N}nk}{x}_{k}k=0,1,2,\cdots ,N-1$$  其中 $i$ 为虚数单位，通常将 $\hat{x}$ 记为 $\hat{x}=\mathcal{F}x$ 或 $y=$ ${\mathrm{D}\mathrm{F}\mathrm{T}}_N$$(x)$。离散傅里叶变换是可逆的线性变换，即有 $\mathcal{F}:{\mathbb{C}}^N\to {\mathbb{C}}^N$。

  定义序列 $\hat{x}$ 的离散傅里叶逆变换 ($\mathrm{I}\mathrm{D}\mathrm{F}\mathrm{T}$) 为$$x_k=\frac{1}{N}\sum _{n=1}^{N-1}{e}^{i\frac{2\pi }{N}nk}{\hat{x}}_{k}k=0,1,2,\cdots ,N-1$$  通常将 $x$ 记为 $x={\mathcal{F}}^{-1}\hat{x}$ 或 $x=$ ${\mathrm{I}\mathrm{D}\mathrm{F}\mathrm{T}}_N$$(y)$。

  ${\mathrm{D}\mathrm{F}\mathrm{T}}_N$ 和 ${\mathrm{I}\mathrm{D}\mathrm{F}\mathrm{T}}_N$ 前的归一化系数通常为 $1$ 和 $\frac{1}{N}$，但有时我们也会统一使用 $\frac{1}{\sqrt{N}}$。

---

快速傅里叶变换

^{fast Fourier transform}

---

  朴素的 $\mathrm{D}\mathrm{F}\mathrm{T}$，复杂度在 $O(n^2)$，通过快速傅里叶变换 ($\mathrm{F}\mathrm{F}\mathrm{T}$) 可以优化至 $O(n\log n)$，不过嗯讲可能太干了，

  先介绍下作用，在信奥赛中，$\mathrm{F}\mathrm{F}\mathrm{T}$ 通常用于加速多项式乘法。

  于是乎，我们先从一点基础内容开始。

---

预备知识

^{getting started}

---

多项式基础

---

  在数学中，若干个关于 $x$ 的单项式相加组成的代数式被称为多项式 $f$，其中最高次项的系数被称为多项式的度，记做 $\mathrm{deg}f$，于是 $f$ 可以被系数表示为：$$\begin{array}{rl}f(x)& =a_0+a_1{x}^1+\cdots +a_{\mathrm{deg}f}{x}^{\mathrm{deg}f}\\ & =\sum _{i=0}^{\mathrm{deg}f}{a}_i{x}^i\end{array}$$

---

多项式系数表示法

---

  多项式系数表示法，就是用多项式的各个项的系数，组成一个系数序列来表示这个多项式，当然，没有要补 $0$，即$：$$$f(x)=\sum _{i=0}^{\mathrm{deg}f}{a}_i{x}^i\iff \{a_0,a_1,a_2,\cdots ,a_{\mathrm{deg}f}\}$$  以下，若无特殊说明，我们均将 $f$ 的系数表示视为列向量 $(a_0,a_1,a_2,\cdots ,a_{\mathrm{deg}f}{)}^T$。

---

多项式点值表示法

---

  多项式 $f$ 显然是一个函数，我们可以从图像上取出 $\mathrm{deg}f+1$ 个不同的点值对来表示它，即$：$$$f(x)=\sum _{i=0}^{\mathrm{deg}f}{a}_i{x}^i\iff \{(x_0,y_0),(x_1,y_0),(x_2,y_2),\cdots ,(x_{\mathrm{deg}f},y_{\mathrm{deg}f})\}$$  $x_k$ 各不相同且都有 $y_k=f(x_k)$，并且多项式点值表示是可逆的，即对于任意 $n$ 个 $x_k$ 各不相同的点值对，都能唯一确定一个 $n-1$ 次多项式，下面给出定理。

---

定理：多项式插值的唯一性

---

  对于任意 $n+1$ 个点值对组成的集合 $\{(x_0,y_0),(x_1,y_1),\cdots ,(x_n,y_n)\}$，都可以唯一确定一个度数为 $n$ 的多项式 $f(x)={\sum }_{i=0}^n{a}_i{x}^i$，满足 $y_k=f(x_k)$。

  简单证明：

  显然有矩阵 $$\left[\begin{array}{ccccc}1& x_0& x_0^2& \cdots & x_0^n\\ 1& x_1& x_1^2& \cdots & x_1^n\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ 1& x_n& x_n^2& \cdots & x_n^n\end{array}\right]\left[\begin{array}{c}{a}_0\\ a_1\\ ⋮\\ a_n\end{array}\right]=\left[\begin{array}{c}{y}_0\\ y_1\\ ⋮\\ y_n\end{array}\right]$$  左项为范德蒙矩阵，若对于任意 $i,j$，$0\le i,j\le n$ 都有 $x_i\ne x_j$，则左项可逆，左乘这个逆矩阵，即可得到 $f(x)$ 系数表示，从而唯一的确定多项式 $f(x)$。

---

多项式乘法

---

  给定多项式 $A(x)={\sum }_{i=0}^{\mathrm{deg}A}{a}_i{x}^i$ 与 $B(x)={\sum }_{i=0}^{\mathrm{deg}B}{b}_i{x}^i$。

  定义 $A\times B$ 的积 $C$ 为$：$$$\begin{array}{rl}C(x)& =A(x)\times B(x)\\ & =\sum _{i=0}^{\mathrm{deg}A}\sum _{j=0}^{\mathrm{deg}B}{a}_i{b}_j{x}^{i+j}\end{array}$$  对于度数分别为 $n、m$ 的多项式，它们的乘积度数为 $n+m$。

  朴素的去计算多项式乘法，复杂度在 $O(n^2)$，但现在我们考虑这样一个情况，若我们知道$：$$$\begin{gathered} A(x)=\{(x_0,A(x_0)),(x_1,A(x_1)),\cdots ,(x_{\mathrm{deg}A+\mathrm{deg}B},A(x_{\mathrm{deg}A+\mathrm{deg}B}))\} \\ B(x)=\{(x_0,B(x_0)),(x_1,B(x_1)),\cdots ,(x_{\mathrm{deg}A+\mathrm{deg}B},B(x_{\mathrm{deg}A+\mathrm{deg}B}))\} \end{gathered}$$  自然能在线性复杂度下计算出$：$$$C(x)=\{(x_0,A(x_0)B(x_0)),(x_1,A(x_1)B(x_1)),\cdots ,(x_{\mathrm{deg}A+\mathrm{deg}B},A(x_{\mathrm{deg}A+\mathrm{deg}B}))B(x_{\mathrm{deg}A+\mathrm{deg}B}))\}$$  $\mathrm{D}\mathrm{F}\mathrm{T}$ 和 $\mathrm{I}\mathrm{D}\mathrm{F}\mathrm{T}$ 在多项式乘法中，扮演的就是多项式系数表示和点值表示之间，转换的这样一个角色，而 $\mathrm{F}\mathrm{F}\mathrm{T}$ 可以将这个过程优化至 $O(n\log n)$，故 $\mathrm{F}\mathrm{F}\mathrm{T}$ 实现的多项式乘法，复杂度在 $O(n\log n)$。

---

复数

---

  形如 $z=a+bi$，$a,b\in \mathbb{R}$ 的数被称为虚数，$a$ 被称为实部，$b$ 被称为虚部，$i$ 被称为虚数单位。

  引入虚数相关的两个公式：

  虚数单位：$i=\sqrt{-1}$
  欧拉函数：$e^{ix}=\cos (x)+i\sin (x)$

---

单位根

---

  数学上，n 次单位根是 n 次幂为 1 的复数。它们位于复平面的单位圆上，构成正多边形的顶点，但最多只可有两个顶点同时标在实数线上。

  摘自 wiki 百科

  定义 $x^n=1$ 的复数根 $x$ 为 $n$ 次单位根，根据欧拉函数，显然它的一个解为 ${\omega }_n=e^{i\frac{2\pi }{n}}$，则它的解集可以表示为 ${\omega }_n^k$，$k=0,1,2,\cdots ,n-1$，故单位的 $n$ 次根有 $n$ 个。

---

单位根的性质

---

  ${\omega }_n^0={\omega }_n^n=1$
  ${\omega }_{2n}^{n+k}=-{\omega }_{2n}^k$
  ${\omega }_{2n}^{2k}={\omega }_n^k$

  简单推算一下式 $2$：

  $e^{i\frac{2(n+k)\pi }{2n}}=\cos (\pi +\frac{k}{n}\pi )+i\sin (\pi +\frac{k}{n}\pi )=-\cos (\frac{k}{n}\pi )-i\sin (\frac{k}{n}\pi )$

  $-e^{i\frac{2k\pi }{2n}}=-\cos (\frac{k}{n}\pi )-i\sin (\frac{k}{n}\pi )$

  当然也可以从在坐标轴上的以原点为中心的单位单位圆上观察出上述三个公式，总之，无论推导方法，它们都是接下来 $\mathrm{F}\mathrm{F}\mathrm{T}$ 中最为核心的一部分，所以熟悉它是掌握 $\mathrm{F}\mathrm{F}\mathrm{T}$ 不可或缺的一部分。

---

FFT

---

  快速傅里叶变换的基本思想就是分治，我们取多项式 $f(x)$ 上的 $2^{\lceil {\log }_2(\mathrm{deg}f)\rceil }$ 个点，运用单位根的性质，分治的去计算 $f(x)$ 在 ${\omega }_n^k$，$k=0,1,2,\cdots ,n-1$ 上的值，从而做到在 $O(n\log n)$ 的复杂度下将 $f$ 的系数表示转换为点值表示。

  具体地说，对于多项式 $C(x)$，我们设 $n=2^{\lceil {\log }_2(\mathrm{deg}C)\rceil }$ 则有$：$$$C(x)=a_0+a_1{x}^1+\cdots +a_{n-1}{x}^{n-1}$$  我们按奇偶次将 $C$ 分为两组$：$$$C(x)=(a_0+a_1{x}^2+\cdots +a_{n-2}{x}^{n-2})+(a_{1}x+a_3{x}^3+\cdots +a_{n-1}{x}^{n-1})$$  然后从右项中提出一个 $x：$$$C(x)=(a_0+a_1{x}^2+\cdots +a_{n-2}{x}^{n-2})+x(a_1+a_3{x}^2+\cdots +a_{n-1}{x}^{n-2})$$  分别令$:$$$\begin{array}{rl}A(x)& =a_0+a_1{x}^2+\cdots +a_{n-2}{x}^{n-2}\\ B(x)& =a_1+a_3{x}^2+\cdots +a_{n-1}{x}^{n-2}\end{array}$$  此时$：$$$\begin{array}{rl}C(x)& =A(x^2)+xB(x^2)\\ C({\omega }_n^x)& =A({\omega }_n^{2x})+{\omega }_n^{x}B({\omega }_n^{2x})\end{array}$$  考虑到 ${\omega }_n^{2x}={\omega }_{n/2}^x$，则有$：$$$C({\omega }_n^x)=A({\omega }_{n/2}^x)+{\omega }_n^{x}B({\omega }_{n/2}^x)$$  有 ${\omega }_n^{x+n/2}=-{\omega }_n^x$，则有$：$$$C({\omega }_n^{x+n/2})=A({\omega }_{n/2}^x)-{\omega }_n^{x}B({\omega }_{n/2}^x)$$  此时，分治的去计算 $A、B$ 在 ${\omega }_{n/2}^k$，$k=0,1,2,\cdots ,\frac{n}{2}-1$ 上的值，即可在 $T(n)=2T(\frac{n}{2})+O(n)$ 即 $O(n\log n)$ 的复杂度下计算出 $C$ 在 ${\omega }_n^k$，$k=0,1,2,\cdots ,n-1$ 上的值。

---

  在实现时，我们可以使用 C99 标准库提供的 来实现复数运行，但有一说一是真的不好用，CPP11 提供 也不大好用，凑合。

  简单的对比一下，以下代码片段中， 所使用的语法均出现在 上面。

  复数的声明$：$

double _Complex z = a + b * I;

std::complex<double> z(a, b);

  实部 | 虚部$：$

printf("z=%lf+%lfi", creal(z), cimag(z));

printf("z=%lf+%lfi", z.real(), z.imag());

  基本运算均重载了运算符，所以这里不做对比。

  好像半斤八两？

---

#include 

typedef std::complex<double> complex;

void FFT(complex *f, int n) {
    if (n == 1) return;
    int t = n >> 1;
    complex A[t], B[t];
    for (int i = 0; i < n; ++i)
        if (i & 1) B[i >> 1] = f[i];
        else A[i >> 1] = f[i];
    FFT(A, t), FFT(B, t);
    complex w(1), wn(cos(2 * M_PI / n), sin(2 * M_PI / n));
    for (int i = 0; i < t; ++i, w *= wn) {
        f[i] = A[i] + w * B[i];
        f[i + t] = A[i] - w * B[i];
    }
}

  如果不聊胜于无的话，我想还是挺值得一提的是 std::exp 重载了对复数的实现，我们可以直接使用 std::exp(complex(0, 2 * M_PI / n)) 来计算 ${\omega }_n$。

---

傅里叶逆变换

^{inverse Fourier transform}

---

预备知识

^{getting started}

---

几何级数求和公式

---

  若一数列，从第一项 $a(a\ne 0)$ 开始，以后它每一项都是它上一项乘以 $r$，即 $$S_n=a+ar+a{r}^2+\cdots +a{r}^{n-1}=\sum _{i=0}^{n-1}a{r}^i$$  便称其为几何级数（或等比级数）。

  若 $r\ne 1$，则有 $$\begin{array}{rl}r{S}_n-S_n& =a{r}^n-a\\ (r-1)S_n& =a(r^n-1)\\ S_n& =\frac{a(r^n-1)}{r-1}\end{array}$$  上式也被称为几何级数求和公式。

---

逆矩阵的性质

---

  ?好像忘了概括一下矩阵

  若矩阵 $A$ 可逆，有 $(A^{-1}{)}^T=(A^T{)}^{-1}$，

  所以，若 $A$ 是对称矩阵，则它的逆矩阵同样也是逆矩阵。

---

IDFT

---

  通过笔者在多项式插值的唯一性的简单证明中易得知，$\mathrm{D}\mathrm{F}\mathrm{T}$ 在多项式$f(x)=\{a_0,a_1,\cdots ,a_{\mathrm{deg}f}\}$ 上所做的，就是求出$$\left[\begin{array}{ccccc}1& {\omega }_n^0& {\omega }_n^0& \cdots & {\omega }_n^0\\ 1& {\omega }_n^1& {\omega }_n^2& \cdots & {\omega }_n^{n-1}\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ 1& {\omega }_n^{n-1}& {\omega }_n^{2(n-1)}& \cdots & {\omega }_n^{(n-1{)}^2}\end{array}\right]\left[\begin{array}{c}{a}_0\\ a_1\\ ⋮\\ a_{n-1}\end{array}\right]=\left[\begin{array}{c}{y}_0\\ y_1\\ ⋮\\ y_{n-1}\end{array}\right]$$  其中 $n=\mathrm{deg}f+1$，我们记 $g=\{y_0,y_1,\cdots ,y_{n-1}\}$，容易想到求出 $V({\omega }_n^0,{\omega }_n^1,\cdots ,{\omega }_n^{n-1}{)}^{-1}$ 左乘 $g$ 傅里叶逆变换出 $f$，其中 $V$ 表示范德蒙矩阵。

  $V({\omega }_n^0,{\omega }_n^1,\cdots ,{\omega }_n^{n-1})$ 显然为对称矩阵，故 $V({\omega }_n^0,{\omega }_n^1,\cdots ,{\omega }_n^{n-1}{)}^{-1}=(a_{i,j}{)}_{n\times n}$ 为对称矩阵，$V({\omega }_n^0,{\omega }_n^1,\cdots ,{\omega }_n^{n-1})(a_{i,j}{)}_{n\times n}=E$，有$$\sum _{i=1}^n{a}_{x,i}{\omega }_n^{yi}=\{\begin{array}{ll}1& x=y\\ 0& \mathrm{o}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}\end{array}$$  根据几何级数求和公式，容易想到 ${\sum }_{i=0}^{n-1}{\omega }_n^{xi}$，若 $x\in \mathbb{Z}$，$n\nmid x$，则有 $\frac{({\omega }_n^x{)}^n-1}{{\omega }_n^x-1}=\frac{({\omega }_n^n{)}^x-1}{{\omega }_n^x-1}=0$，$x=0$，则有 ${\sum }_{i=0}^{n-1}{\omega }_n^0=n$，故我们另 $a_{i,j}={\omega }_n^{-(i-1)(j-1)}$，则有$$\sum _{i=1}^n{\omega }_n^{-xi}{\omega }_n^{yi}=\{\begin{array}{ll}n& x=y\\ 0& \mathrm{o}\mathrm{t}\mathrm{h}\mathrm{e}\mathrm{r}\mathrm{w}\mathrm{i}\mathrm{s}\mathrm{e}\end{array}$$  $0\le x,y<n$，故 $-n<x-y<n$，上式从而成立。

  这里我们就能发现，对 $g$ 做一遍 $\mathrm{D}\mathrm{F}\mathrm{T}$，变化时单位根指数取反，就能得到 $nf$。

typedef std::complex<double> complex;

void FFT(complex *f, int n, int opt) {
    if (n == 1) return;
    int t = n >> 1;
    complex A[t], B[t];
    for (int i = 0; i < n; ++i)
        if (i & 1) B[i >> 1] = f[i];
        else A[i >> 1] = f[i];
    FFT(A, t, opt), FFT(B, t, opt);
    complex w(1), wn = std::exp(complex(0, opt * 2 * M_PI / n));
    for (int i = 0; i < t; ++i, w *= wn) {
        f[i] = A[i] + w * B[i];
        f[i + t] = A[i] - w * B[i];
    }
}

const int n = 8;

int main() {
    complex A[n]{1, 1, 4, 5, 1, 4};
    FFT(A, n, +1);
    FFT(A, n, -1);
    for (int i = 0; i < n; ++i) A[i] /= n;
    for (int i = 0; i < n; ++i)
        printf("%d", (int)(A[i].real() + 0.5));
    return 0;
}

---

一些优化

---

蝴蝶操作

^{bit-reversal permutation}

---

  递归程序一种朴素的优化思路就是：递归转迭代，但要实现递归转迭代，第一件要解决的事情，就是弄清递归到 “叶节点” 时，当前的操作数与原系数序列的关系。

  蝴蝶操作可以在线性时间内，将原系数序列按分治操作最底层顺序重排，如当 $n=8$ 时$：$$$\begin{gathered} \{a_0,a_1,a_2,a_3,a_4,a_5,a_6,a_7\} \\ \{a_0,a_2,a_4,a_6\}\{a_1,a_3,a_5,a_7\} \\ \{a_0,a_4\}\{a_2,a_4\}\{a_1,a_5\}\{a_3,a_7\} \end{gathered}$$  对 $\{a_0,a_1,a_2,a_3,a_4,a_5,a_6,a_7\}$ 进行蝴蝶操作后，就能得到 $\{a_0,a_4,a_2,a_4,a_1,a_5,a_3,a_7\}$。

  易得知 $a_i$ 在 $A(x)、B(x)$ 间，项数的奇偶性可能是不断变化的，比如 $a_2$ 为偶数项，则他在递归第一层的位置为 $\lceil \frac{2+1}{2}\rceil$，变成了奇数项，而$a_3$ 为奇数项，则他在递归第一层的位置为 $\lceil \frac{3+1}{2}\rceil +\frac{n}{2}$，变成了偶数项。

  我们将 $i$ 与 $a_i$ 最终的位置 $i^{\prime }$ 按二进制拆分，容易发现，若 $i$ 最低位为 $1$，则 $i^{\prime }$ 的最高位为 $1$，否则为 $0$，然后对 $\lfloor \frac{i}{2}\rfloor$（不要混淆了位置和序号）重复进行这个判断，最后 $i^{\prime }$ 恰等于 $i$ 在二进制表示下的反转。

  于是我们可以构造一个数列 $rev$，$re{v}_i$ 表示 $i$ 在二进制表示下反转的值，若我们顺序计算 $rev$，容易发现计算 $re{v}_i$ 时 $re{v}_{i/2}$ 已经被计算出来，若 $i$ 为偶数。则 $re{v}_i$ 等于 $re{v}_{i/2}$ 右移一位，否则就在此基础上加上 $\frac{n}{2}$，然后顺序交换元素就能在线性时间内完成蝴蝶操作。

#include 

typedef std::complex<double> complex;

void FFT(complex *f, int n, int opt) {
    if (n == 1) return;
    int t = n >> 1;
    FFT(f, t, opt), FFT(f + t, t, opt);
    complex w(1), wn = std::exp(complex(0, opt * 2 * M_PI / n));
    for (int i = 0; i < t; ++i, w *= wn) {
        complex tmp = w * f[i + t];
        f[i + t] = f[i] - tmp;
        f[i] += tmp;
    }
}

const int n = 8;

int rev[n];

int main() {
    for (int i = 0; i < n; ++i)
        rev[i] = rev[i >> 1] >> 1 | (i & 1) * (n >> 1);
    complex A[n]{1, 1, 4, 5, 1, 4};
    for (int i = 0; i < n; ++i)
        if (i < rev[i]) std::swap(A[i], A[rev[i]]);
    FFT(A, n, +1);
    for (int i = 0; i < n; ++i)
        if (i < rev[i]) std::swap(A[i], A[rev[i]]);
    FFT(A, n, -1);
    for (int i = 0; i < n; ++i) A[i] /= n;
    for (int i = 0; i < n; ++i)
        printf("%d", (int)(A[i].real() + 0.5));
    return 0;
}

---

迭代实现

---

  基操，没啥好说的。

#include 

typedef std::complex<double> complex;

const int N = 8;

int rev[N];

void FFT(complex *f, int lim, int opt) {
    for (int i = 0; i < lim; ++i)
        if (i < rev[i]) std::swap(f[i], f[rev[i]]);
    for (int n = 2; n <= lim; n <<= 1) {
        int t = n >> 1;
        complex wn = std::exp(complex(0, opt * 2 * M_PI / n));
        for (int i = 0; i < lim; i += n) {
            complex w(1);
            for (int j = 0; j < t; ++j, w *= wn) {
                complex tmp = w * f[i + j + t];
                f[i + j + t] = f[i + j] - tmp;
                f[i + j] = f[i + j] + tmp;
            }
        }
    }
    if (opt == -1)
        for (int i = 0; i < lim; ++i) f[i] /= lim;
}

int main() {
    for (int i = 0; i < N; ++i)
        rev[i] = rev[i >> 1] >> 1 | (i & 1) * (N >> 1);
    complex A[N]{1, 1, 4, 5, 1, 4};
    FFT(A, N, +1);
    FFT(A, N, -1);
    for (int i = 0; i < N; ++i)
        printf("%d", (int)(A[i].real() + 0.5));
    return 0;
}

---

IDFT 另一种思路

---

  设 $f(x)=\{a_0,a_1,\cdots ,a_{n-1}\}$，$n=\mathrm{deg}f+1$，构造多项式 $$g(x)=\sum _{i=0}^{n-1}f({\omega }_n^i)x^i$$  将 ${\omega }_n^k$，$k=0,1,2,\cdots ,n-1$ 依次代入式中，易知$$\begin{array}{rl}g({\omega }_n^k)& =\sum _{i=0}^{n-1}\sum _{j=0}^{n-1}{a}_j({\omega }_n^i{)}^j({\omega }_n^i{)}^k\\ & =\sum _{j=0}^{n-1}\sum _{i=0}^{n-1}{a}_j({\omega }_n^{j+k}{)}^i\\ & =\sum _{j=0}^{n-1}{a}_j\sum _{i=0}^{n-1}({\omega }_n^{j+k}{)}^i\end{array}$$  根据几何级数求和公式，容易得知 $g({\omega }_n^k)=n{a}_{n-k}$，计算过程大致与 $\mathrm{I}\mathrm{D}\mathrm{F}\mathrm{T}$ 相同，

  所以我们直接对 $g$ 做一遍 $\mathrm{D}\mathrm{F}\mathrm{T}$，然后将第 $2$ 至 $n$ 个元素依次除 $n$ 反转，整个操作的复杂度在 $O(n)$，不过单位根取倒操作，单独拎出来复杂度在 $O(\log n)$

  了解着玩就行了。

#include 

typedef std::complex<double> complex;

const int N = 8;

int rev[N];

void FFT(complex *f, int lim, bool inv) {
    for (int i = 0; i < lim; ++i)
        if (i < rev[i]) std::swap(f[i], f[rev[i]]);
    for (int n = 2; n <= lim; n <<= 1) {
        int t = n >> 1;
        complex wn = std::exp(complex(0, 2 * M_PI / n));
        for (int i = 0; i < lim; i += n) {
            complex w(1);
            for (int j = 0; j < t; ++j, w *= wn) {
                complex tmp = w * f[i + j + t];
                f[i + j + t] = f[i + j] - tmp;
                f[i + j] = f[i + j] + tmp;
            }
        }
    }
    if (inv) {
        for (int i = 1, j = lim - 1; i < j; ++i, --j)
            std::swap(f[i], f[j]), f[i] /= lim, f[j] /= lim;
        f[0] /= lim, f[lim >> 1] /= lim;
    }
}

int main() {
    for (int i = 0; i < N; ++i)
        rev[i] = rev[i >> 1] >> 1 | (i & 1) * (N >> 1);
    complex A[N]{1, 1, 4, 5, 1, 4};
    FFT(A, N, 0);
    FFT(A, N, 1);
    for (int i = 0; i < N; ++i)
        printf("%d", (int)(A[i].real() + 0.5));
    return 0;
}

---

FFT 的应用

---

  $\mathrm{F}\mathrm{F}\mathrm{T}$ 的应用有很多，能力有限就不乱介绍了。

---

A × B Problem 升级版

^{P1919 【模板】A*B Problem 升级版}

---

  给你两个正整数 $a,b$，求 $a\times b$，$1\le a,b\le 10^{1000000}$。

---

  设 $$\begin{array}{rl}A(x)& =a_0+a_{1}x+a_2{x}^2+\cdots +a_{\lfloor {\log }_{10}a\rfloor }{x}^{\lfloor {\log }_{10}a\rfloor }\\ B(x)& =b_0+b_{1}x+b_2{x}^2+\cdots +b_{\lfloor {\log }_{10}b\rfloor }{x}^{\lfloor {\log }_{10}b\rfloor }\end{array}$$  其中，$a_i、b_j$ 分别为 $a、b$ 在 $10^i、10^j$ 位上的数，不难得知 $a=A(10)、b=B(10)$，而根据多项乘法的定义 $C(x)=\sum _{i=0}^{\mathrm{deg}A}\sum _{j=0}^{\mathrm{deg}B}{a}_i{b}_j{x}^{i+j}$，不难得出 $$\begin{array}{rl}C(10)& =\sum _{i=0}^{{\log }_{10}a}\sum _{j=0}^{{\log }_{10}b}{a}_i{b}_{j}10^{i+j}\\ & =\sum _{i=0}^{{\log }_{10}a}{a}_{i}10^i\sum _{j=0}^{{\log }_{10}b}{b}_{j}10^j\\ & =a\times b\end{array}$$  在笔者介绍多项式乘法时已经给出了一种 $\mathrm{D}\mathrm{F}\mathrm{T}$ 做法，这里给出另一种更为高效的做法，考虑到复数 $z=a+bi$ 的平方 $$\begin{array}{rl}{z}^2& =(a+bi{)}^2\\ & =a^2+2abi+b^2{i}^2\\ & =(a^2-b^2)+2abi\end{array}$$  聪明的读者恐怕已经想到，我们构造一个多项式 $G(x)={\sum }_{k=0}^{i+j}{c}_i{x}^i$，将 $a_i$ 放入到 $c_i$ 的实部或虚部，将 $b_j$ 放入到另一部，然后对 ${\mathrm{D}\mathrm{F}\mathrm{T}}_N$$G$ 每一项系数都平方后再 $\mathrm{I}\mathrm{D}\mathrm{F}\mathrm{T}$ 回来，此时 $c_k$ 的虚部除以二就是 $C=A\times B$ 真正的系数。

#include 
#include 
#include 

typedef std::complex<double> complex;

const int N = 1 << 21;

complex f[N];

char buf[N];

int rev[N];

void FFT(complex *f, int lim, int opt) {
    for (int i = 0; i < lim; ++i)
        if (i < rev[i]) std::swap(f[i], f[rev[i]]);
    for (int n = 2; n <= lim; n <<= 1) {
        int t = n >> 1;
        complex wn = std::exp(complex(0, opt * 2 * M_PI / n));
        for (int i = 0; i < lim; i += n) {
            complex w(1);
            for (int j = 0; j < t; ++j, w *= wn) {
                complex tmp = w * f[i + j + t];
                f[i + j + t] = f[i + j] - tmp;
                f[i + j] = f[i + j] + tmp;
            }
        }
    }
    if (opt == -1)
        for (int i = 0; i < lim; ++i) f[i] /= lim;
}

int n, m, len = 0, lim = 1;

int main() {
    scanf("%s", buf);
    n = strlen(buf);
    for (int i = 0, j = n; j; ++i)
        f[i] += complex(buf[--j] - '0', 0);
    scanf("%s", buf);
    m = strlen(buf);
    for (int i = 0, j = m; j; ++i)
        f[i] += complex(0, buf[--j] - '0');
    while (lim < n + m) lim <<= 1;
    for (int i = 0; i < lim; ++i)
        rev[i] = rev[i >> 1] >> 1 | (i & 1) * (lim >> 1);
    FFT(f, lim, +1);
    for (int i = 0; i < lim; ++i) f[i] *= f[i];
    FFT(f, lim, -1);
    for (int add = 0, now; len < n + m || add; ++len) {
        now = f[len].imag() / 2 + 0.5 + add;
        buf[len] = now % 10 + '0';
        add = now / 10;
    }
    if (buf[len - 1] == '0') --len;
    while (len) putchar(buf[--len]);
    return 0;
}

  优雅，永不过时。