学习笔记 - 快速傅里叶变换 / 大数A * B的另一种解法

---

前言

Fast Fast TLE

原本做大数乘法的时候是想偷懒的, 就百度了下大数 A * B 的代码, 无意中发现有使用FFT的做法, 于是便开始了学习 (受苦) , 本文用以记录仅在算法应用层面上我对FFT的理解和一个手搓的大数乘法模版.

需要一定的复数知识, 但不多.

笔者对FFT的理解较为粗浅, 因此在下文可能大量略过某些部分的详细证明, 请见谅!

一、FFT是什么?

快速傅里叶变换( Fast Fourier Transform ), 是一种对离散傅里叶变换( Discrete Fourier Transform )的优化, 可令离散傅里叶变换的运算量大大降低, 在取样点数量较多的情况下可显著提升效率

二、FFT可以干什么?

1.多项式乘法

实际上, FFT可以大大提升卷积¹的计算效率, 而当卷积的两个函数为多项式的时候, FFT则能在多项式乘法上大显神威.

2.大数乘法

关于乘法, 朴素的算法则是模拟我们自小学会的竖式乘法, 不难证明这样的算法的复杂度为O(n²), 然而这样的算法不仅容易精度溢出, 效率也不够高, 应用FFT则可以使算法的复杂度降低至O(nlogn).

观察一个数字, 如123456, 换种角度思考, 可以将其转化为以下的式子:$$123456=1\ast 10^5+2\ast 10^4+3\ast 10^3+4\ast 10^2+5\ast 10^1+6\ast 10^0$$再转化一次, 令x = 10, 则可以得到:$$1\ast x^5+2\ast x^4+3\ast x^3+4\ast x^2+5\ast x^1+6\ast x^0$$
从这个角度思考, 大数乘法不正是x = 10的情况下的多项式乘法吗?

三、FFT怎么做?

PS:强烈建议您通过这个视频进行学习并在需要的情况下结合下文理解, 个人认为这个视频讲得相当易懂

1. 系数表示法和点值表示法

任取一个n-1阶² 多项式, 将其表示为$$a_0+a_{1}x+a_2{x}^2+...+a_{n-1}{x}^{n-1}$$实际上我们已经得到了它的系数表示, 即$$\left[\begin{array}{lcccc}{a}_0& a_1& a_2& ...& a_{n-1}\end{array}\right]$$
那么什么是它的点值表示法呢?

对一个多项式$$f(x)=a_0+a_{1}x+a_2{x}^2+...+a_{n-1}{x}^{n-1}$$任取不小于n个x_i带入并计算得到f(x_i)即为其点值表示法:
$$\left\{(x_0,f(x_0),(x_1,f(x_1),\dots ,(x_{n-1},f(x_{n-1})\right\}$$

将其化为矩阵形式, 有
$$\left[\begin{array}{l}f(x_1)\\ f(x_2)\\ ⋮\\ f(x-1)\end{array}\right]=\left[\begin{array}{lcccc}1& x_0& x_0^2& \dots & x_0^{n-1}\\ 1& x_1& x_1^2& \dots & x_1^{n-1}\\ \dots & \dots & \dots & ⋮& \dots \\ 1& x_{n-1}& x_{n-1}^2& \dots & x_{n-1}^{n-1}\end{array}\right]\left[\begin{array}{l}{a}_0\\ a_1\\ ⋮\\ a_{n-1}\end{array}\right]$$
PS:从 系数表示法 得到 点值表示法 的这一步即为DFT(离散傅里叶变换)

由范德蒙德行列式易证得当x₀ ~ x_n-1互不相同时矩阵可逆, 即当所取的x_i不小于矩阵的阶加一时, 点值表示法和系数表示法一一对应.

令$$h(x)=f(x)g(x)$$
在点值表示法的基础上, 要计算h(x)的表达式, 只需要取相同的x_i得出f(x_i)和g(x_i)并相乘, 再从(x_i ,f(x_i)g(x_i))的点值表示法转换成系数表示法即可得到h(x)的值.

那么如何从点值表示法转换成系数表示法呢? 仔细观察上面的矩阵表达式不难得出:

$$\left\{(x_0,f(x_0),(x_1,f(x_1),\dots ,(x_{n-1},f(x_{n-1})\right\}$$

将其化为矩阵形式, 有
$$\left[\begin{array}{l}{a}_0\\ a_1\\ ⋮\\ a_{n-1}\end{array}\right]={\left[\begin{array}{lcccc}1& x_0& x_0^2& \dots & x_0^{n-1}\\ 1& x_1& x_1^2& \dots & x_1^{n-1}\\ \dots & \dots & \dots & ⋮& \dots \\ 1& x_{n-1}& x_{n-1}^2& \dots & x_{n-1}^{n-1}\end{array}\right]}^{-1}\left[\begin{array}{l}f(x_1)\\ f(x_2)\\ ⋮\\ f(x-1)\end{array}\right]$$
PS:从 点值表示法 得到 系数表示法 的这一步即为Inverse DFT(逆离散傅里叶变换)

3.如何巧妙地进行DFT? - FFT的高明之处

对上述的DFT过程, 一个通常的想法是在x轴上随便挑几个点代入计算, 比如说x₀= 0, x₁ = 1, …然而这样做的话又重新掉入了O(n²)的窠臼之中, 我们依旧需要对n个甚至以上的点计算n次, 而要探讨FFT的做法, 让我们先着眼于两个简单的多项式
$$P_1=x^2$$
因为这是一个偶函数, 当我们确定f(x_i)时通过偶函数的性质可以立刻确定f(-x_i) = f(x_i), 这样我们任取一个点, 立刻就可以确定其相反数的函数值了.

而对于
$$P_2=x^3$$
和P₁不同, 这是个奇函数, 因此f(-x_i) = -f(x_i).

据此, 我们不妨将一个一般的多项式(设n为偶数)分解为奇函数的部分和偶函数的部分, 再从奇函数部分提取一个x:
$$\begin{gathered} P(x)=a_0+a_{1}x+a_2{x}^2+...+a_{n-1}{x}^{n-1} \\ 令P_e(x)=a_0+a_2{x}^2+...+a_{n-2}{x}^{n-2},P_o(x)=a_1+a_3{x}^2+...+a_{n-1}{x}^{n-2} \\ 则P(x_i)=P_e(x_i)+x_i{P}_o(x_i), \\ P(-x_i)=P_e(x_i)-x_i{P}_o(x_i) \end{gathered}$$
若令 p = x², 则Pe(x)和Po(x)则简化为以下式子:
$$\begin{gathered} P_e(x)=a_0+a_2{x}^2+...+a_{n-2}{x}^{n-2} \\ {P}_o(x)=a_1+a_3{x}^2+...+a_{n-1}{x}^{n-2} \\ \Updownarrow 令p=x^2 \\ {P}_e(p)=a_0+a_{2}p+...+a_{n-2}{p}^{\frac{n-2}{2}} \\ {P}_o(p)=a_1+a_{3}p+...+a_{n-1}{p}^{\frac{n-2}{2}} \end{gathered}$$
如果此时将P_e和P_o视为新的式子, 重复上述操作则可将P_e和P_o继续降阶直到P_e和P_o的式子的阶降至0, 那么此时P_e和P_o的值便为常数a₀和a₁.

以多项式P(x) = a₀ + a₁x + a₂x² + a₃x²为例, DFT过程需要构造4个根x₁, x₂, x₃, x₄并带入求值, 以上述方法降阶则有:

第一步:
$$\begin{gathered} P_0(x)=a_0+a_{1}x+a_2{x}^2+a_3{x}^3 \\ \Updownarrow 令t=x^2 \\ {P}_{e0}(t)=a_0+a_{2}t \\ {P}_{o0}(t)=a_1+a_{3}t \\ {P}_0(x_i)=P_{e0}(x_i^2)+x_i{P}_{o0}(x_i^2), \\ {P}_0(-x_i)=P_{e0}(x_i^2)-x_i{P}_{o0}(x_i^2) \end{gathered}$$

---

第二步:

$$\begin{array}{cc}令P_1=P_{e0}(t)=a_0+a_{2}t,& 令P_2=P_{o0}(t)=a_1+a_{3}t,\\ 则P_{e1}(t)=a_0,& 则P_{e2}(t)=a_1,\\ P_{o1}(t)=a_2& P_{e2}(t)=a_3\\ P_1(x_i^2)=P_{e1}(x_i^2)+x_i^2{P}_{o1}(x_i^2)=a_0+x_i^2\cdot a_2,& P_2(x_i^2)=P_{e2}(x_i^2)+x_i^2{P}_{o2}(x_i^2)=a_1+x_i^2\cdot a_3,\\ P_1(-x_i^2)=P_{e1}(-x_i^2)-x_i^2{P}_{o1}(x_i^2)=a_0-x_i^2\cdot a_2& P_2(-x_i^2)=P_{e2}(-x_i^2)-x_i^2{P}_{o2}(x_i^2)=a_1-x_i^2\cdot a_3\end{array}$$
如此, 对P₀(x)的快速傅里叶变换过程已经呼之欲出了, 然而这里却有一个严重的问题亟待解决……

4. 单位复根 - FFT的高明之处(二)

也许你已经注意到了其中的问题, 让我们回到上述第二步, 该如何取x_i的值才能使得x₀²与x₁²互为相反数呢, 显然在实数域中这个问题是无法被解决的.

这就是FFT的第二个高明之处, 使用n次单位复根来解决问题.

让我们继续使用上面那个多项式P₀(x), 我们需要4个数作为x代入多项式并求值, 从而得出P₀(x)的点值表达式, 那么我们不妨使用4次单位复根(1, -1, i, -i)作为 x_i :
$$\begin{gathered} 求P_0(x_i)的值,其中P_0(x)=a_0+a_{1}x+a_2{x}^2+a_3{x}^3,x_i=\left[1,-1,i,-i\right] \\ {P}_0(1)=P_{e0}(1)+1\cdot P_{o0}(1), \\ {P}_0(-1)=P_{e0}(1)-1\cdot P_{o0}(1) \\ {P}_0(i)=P_{e0}(-1)+i\cdot P_{o0}(-1), \\ {P}_0(-1)=P_{e0}(-1)-i\cdot P_{o0}(-1) \end{gathered}$$

---

$$\begin{gathered} P_{e0}(1)=P_1(1)=P_{e1}(1)+1\cdot P_{o1}(1)=a_0+1\cdot a_2, \\ {P}_{e0}(-1)=P_1(-1)=P_{e1}(-1)-1\cdot P_{o1}(1)=a_0-1\cdot a_2 \\ {P}_{o0}(1)=P_1(1)=P_{e2}(1)+1\cdot P_{o2}(1)=a_1+1\cdot a_3, \\ {P}_{o0}(-1)=P_1(-1)=P_{e2}(-1)-1\cdot P_{o2}(1)=a_1-1\cdot a_3 \end{gathered}$$
再将值代入上式, 整个FFT过程便结束了.

当然单位复根的其他(我并不熟知)的性质(如可约引理, 等分引理, 求和引理等), 造就了其十分适合用于快速傅里叶变换中.

简单来说, 对于n次单位复根(其中n是2的正整数次幂), 他们之间两两正负配对(第k个根与第k + n/2个根)且平方后同样两两正负配对, 这令其十分适合用于递归当中.

当然, 这些性质在n是2的正整数次幂时才生效, 当n不是2的正整数次幂时, 可自行将多项式的次数补足, 此时该项系数为0即可.

当然由于我十分的菜, 具体的证明就此略过了, 各位可以看看我推荐的那个视频或者自行寻找资料进行证明(

5. Inverse Fast Fourier Transform - 从点值表示法回到系数表示法

这一步骤之简单你绝对无法想象, 观察上文的IDFT的实现:
$$\left[\begin{array}{l}{a}_0\\ a_1\\ ⋮\\ a_{n-1}\end{array}\right]={\left[\begin{array}{lcccc}1& x_0& x_0^2& \dots & x_0^{n-1}\\ 1& x_1& x_1^2& \dots & x_1^{n-1}\\ \dots & \dots & \dots & ⋮& \dots \\ 1& x_{n-1}& x_{n-1}^2& \dots & x_{n-1}^{n-1}\end{array}\right]}^{-1}\left[\begin{array}{l}f(x_1)\\ f(x_2)\\ ⋮\\ f(x-1)\end{array}\right]$$
让我们对第二个矩阵进行求逆:
$${\left[\begin{array}{lcccc}1& x_0& x_0^2& \dots & x_0^{n-1}\\ 1& x_1& x_1^2& \dots & x_1^{n-1}\\ \dots & \dots & \dots & ⋮& \dots \\ 1& x_{n-1}& x_{n-1}^2& \dots & x_{n-1}^{n-1}\end{array}\right]}^{-1}={\left[\begin{array}{lcccc}1& 1& 1& \dots & 1\\ 1& \omega & {\omega }^2& \dots & {\omega }^{n-1}\\ \dots & \dots & \dots & ⋮& \dots \\ 1& {\omega }^{n-1}& {\omega }^{2(n-1)}& \dots & {\omega }^{(n-1)(n-1)}\end{array}\right]}^{-1}=\frac{1}{n}\left[\begin{array}{lcccc}1& 1& 1& \dots & 1\\ 1& {\omega }^{-1}& {\omega }^{-2}& \dots & {\omega }^{-(n-1)}\\ \dots & \dots & \dots & ⋮& \dots \\ 1& {\omega }^{-(n-1)}& {\omega }^{-2(n-1)}& \dots & {\omega }^{-(n-1)(n-1)}\end{array}\right]$$其中
$$x_k={\omega }_k,\omega =e^{\frac{2\pi i}{n}}$$
也就是说:
$$\left[\begin{array}{l}{p}_0\\ p_1\\ ⋮\\ p_{n-1}\end{array}\right]=\frac{1}{n}\left[\begin{array}{lcccc}1& 1& 1& \dots & 1\\ 1& \omega & {\omega }^2& \dots & {\omega }^{n-1}\\ \dots & \dots & \dots & ⋮& \dots \\ 1& {\omega }^{n-1}& {\omega }^{2(n-1)}& \dots & {\omega }^{(n-1)(n-1)}\end{array}\right]\left[\begin{array}{l}P(x_1)\\ P(x_2)\\ ⋮\\ P(x-1)\end{array}\right]$$
不难发现, 要实现IFFT, 只需在FFT的基础上将ω取倒数, 并在最终结果乘以n分之一即可.

PS:我觉得自己写的FFT解释很烂, 在此建议您如果 (肯定) 有看不懂的部分结合刚才推荐的视频学习

四、FFT的递归实现

据此, 我们终于可以写出FFT的代码了, 我手写的递归实现如下:

#include 

using namespace std;

typedef unsigned long long ull;
const double Pi = acos(-1.0);	//将常数Pi的值设为arccos(-1)

vector<complex<double> > FFT(vector<complex<double> > &a, int flag) {
     
	//第一个参数为一个多项式的系数, 以次数从小到大的顺序, 向量中每一项的实部为该项系数
    //flag == 1->FFT, flag == -1->IFFT
    int n = a.size();
    if(n == 1)		//如果当前多项式仅有常数项时直接返回多项式的值
        return a;
    vector<complex<double> > Pe, Po;		//即原文中的Pe与Po的系数表示法
    complex<double> omega(cos(2.0 * Pi / n), sin(flag * 2.0 * Pi / n)), cur(1, 0);		//omega为第一个n次复根, cur为第零个n次复根即1
    for (unsigned int i = 0; i < n; i++) {
     
        if(i & 1)
            Po.push_back(a[i]);
        else
            Pe.push_back(a[i]);
    }
    vector<complex<double> > ye = FFT(Pe, flag), yo = FFT(Po, flag), y(n);		//递归求得ye=Pe(xi), yo=Po(xi)
    for (int i = 0; i < n / 2; i++) {
     
        y[i] = ye[i] + cur * yo[i];				//求出P(xi)
        y[i + n / 2] = ye[i] - cur * yo[i];		//由单位复根的性质可知第k个根与第k + n/2个根互为相反数
        cur *= omega;							//cur * omega得到下一个复根
    }
    return y;			//返回最终的系数
}

当然需要注意的是, 如果当前进行的是IFFT时, 需要将最终结果除以n, 其中n为不小于原多项式阶+1的最小2的整数次幂.

因此你需要在上述代码的基础上增加一个代码, 向原系数向量补0直到向量中元素的个数为二的整数幂为止.

五、大数乘法的实现(FFT版)

了解了FFT的实现方法, 大数乘法的实现可以说是再简单不过了(毕竟前面的鬼东西都看懂了), 这里便直接贴上源代码了,当然有一个非常需要注意的地方, 最终获取的多项式系数是有可能大于等于10的, 此时需要做进位处理!

#include 

#define sync ios::sync_with_stdio(false)

using namespace std;

typedef unsigned long long ull;
const double Pi = acos(-1.0);	//将常数Pi的值设为arccos(-1)

vector<complex<double> > FFT(vector<complex<double> > &a, int flag) {
     
	//第一个参数为一个多项式的系数, 以次数从小到大的顺序, 向量中每一项的实部为该项系数
    //flag == 1->FFT, flag == -1->IFFT
    int n = a.size();
    if(n == 1)		//如果当前多项式仅有常数项时直接返回多项式的值
        return a;
    vector<complex<double> > Pe, Po;		//即原文中的Pe与Po的系数表示法
    complex<double> omega(cos(2.0 * Pi / n), sin(flag * 2.0 * Pi / n)), cur(1, 0);		//omega为第一个n次复根, cur为第零个n次复根即1
    for (unsigned int i = 0; i < n; i++) {
     
        if(i & 1)
            Po.push_back(a[i]);
        else
            Pe.push_back(a[i]);
    }
    vector<complex<double> > ye = FFT(Pe, flag), yo = FFT(Po, flag), y(n);		//递归求得ye=Pe(xi), yo=Po(xi)
    for (int i = 0; i < n / 2; i++) {
     
        y[i] = ye[i] + cur * yo[i];				//求出P(xi)
        y[i + n / 2] = ye[i] - cur * yo[i];		//由单位复根的性质可知第k个根与第k + n/2个根互为相反数
        cur *= omega;							//cur * omega得到下一个复根
    }
    return y;			//返回最终的系数
}

vector<complex<double> > read() {
     	//获取系数, 注意需要从右向左获取(从0次幂的系数开始)
    string num;
    cin >> num;
    vector<complex<double> > result;
    for (int i = num.size() - 1; i >= 0; i--) {
     
        complex<double> tmp(num[i] - '0', 0);
        result.push_back(tmp);
    }
    return result;
}

void solve(vector<complex<double> > &a, vector<complex<double> > &b) {
     		//多项式系数表达式的修饰
    complex<double> tmp(0, 0);
    int sum = a.size() + b.size();
    while (a.size() < sum)
        a.push_back(tmp);
    while (b.size() < sum)
        b.push_back(tmp);
    //如果两式的阶不同, 先补齐
    int temp = 1;
    while (temp < a.size())
        temp <<= 1;
    //获取不小于n的最小2的整数次幂
    while (a.size() < temp) {
     
        a.push_back(tmp);
        b.push_back(tmp);
    }
    //补齐
}

int main() {
     
    sync;
    vector<complex<double> > num1 = read(), num2 = read(), tmp1, tmp2, mid, ans;
    solve(num1, num2);
    tmp1 = FFT(num1, 1), tmp2 = FFT(num2, 1);
    num1.clear();
    num2.clear();
    for (int i = 0; i < tmp1.size(); i++)
        mid.push_back(tmp1[i] * tmp2[i]);
    tmp1.clear();
    tmp2.clear();
    ans = FFT(mid, -1);
    bool Ans = false;
    int add = 0;
    string final;
    //进位处理
    for (int i = 0; i < ans.size(); i++) {
     
        int op = round(round(ans[i].real()) / ans.size()) + add;
        add = 0;
        if(op >= 10)
            add = op / 10;
        final += op % 10 + '0';
    }
    if(add > 0)
        final += add % 10 + '0';
    for (int i = final.size() - 1; i >= 0; i--) {
     
        if(final[i] != '0')
            Ans = true;
        else if(!Ans)
            continue;
        cout << final[i];
    }
    cout << '\n';
}

后话(废话)

1. 历时一个寒假! 终于把这篇万字长文(x)写完了, 多谢某csome同学的鼓励~~(催更)~~ !
2. 理解FFT足足花了2天时间, 好难……
3. 如果博客有错漏, 敬请指出并不吝赐教, 感谢!

---

1. 卷积的定义请参见维基对卷积的定义. ↩︎

2. 多项式的次数最大的项的次数即为多项式的阶. ↩︎