HDU 1402 FFT 求 大数乘法

这题的数据量是5w, 也就是传统意义上的n^2算法是不可取的。这里就用到了FFT


FFT一般的作用就是使得多项式乘法的复杂度降到nlogn。利用FFT可以快速求出循环卷积。

那么卷积又是什么样一个东西。

----------------------------------------以下内容转自http://blog.sina.com.cn/s/blog_6733026501019ubf.html--------------------

信号处理中的一个重要运算是卷积.初学卷积的时候,往往是在连续的情形,
  两个函数f(x),g(x)的卷积,是∫f(u)g(x-u)du
  当然,证明卷积的一些性质并不困难,比如交换,结合等等,但是对于卷积运算的来处,初学者就不甚了了。
  
  其实,从离散的情形看卷积,或许更加清楚,
  对于两个序列f[n],g[n],一般可以将其卷积定义为s[x]= ∑f[k]g[x-k]
  
  卷积的一个典型例子,其实就是初中就学过的多项式相乘的运算,
  比如(x*x+3*x+2)(2*x+5)
  一般计算顺序是这样,
  (x*x+3*x+2)(2*x+5)
  = (x*x+3*x+2)*2*x+(x*x+3*x+2)*5
  = 2*x*x*x+3*2*x*x+2*2*x+ 5*x*x+3*5*x+10
  然后合并同类项的系数,
  2 x*x*x
  3*2+1*5 x*x
  2*2+3*5 x
  2*5
  ----------
  2*x*x*x+11*x*x+19*x+10
  
  实际上,从线性代数可以知道,多项式构成一个向量空间,其基底可选为
  {1,x,x*x,x*x*x,...}
  如此,则任何多项式均可与无穷维空间中的一个坐标向量相对应,
  如,(x*x+3*x+2)对应于
  (1 3 2),
  (2*x+5)对应于
  (2,5).
  
  线性空间中没有定义两个向量间的卷积运算,而只有加法,数乘两种运算,而实际上,多项式的乘法,就无法在线性空间中说明.可见线性空间的理论多么局限了.
  但如果按照我们上面对向量卷积的定义来处理坐标向量,
  (1 3 2)*(2 5)
  则有
  2 3 1
  _ _ 2 5
  --------
      2
  
  
  2 3 1
  _ 2 5
  -----
    6+5=11
  
  2 3 1
  2 5
  -----
  4+15 =19
  
  
  _ 2 3 1
  2 5
  -------
    10
  
   或者说,
  (1 3 2)*(2 5)=(2 11 19 10)
  
  回到多项式的表示上来,
  (x*x+3*x+2)(2*x+5)= 2*x*x*x+11*x*x+19*x+10
  
  似乎很神奇,结果跟我们用传统办法得到的是完全一样的.
  换句话,多项式相乘,相当于系数向量的卷积.
  
  其实,琢磨一下,道理也很简单,
  卷积运算实际上是分别求 x*x*x ,x*x,x,1的系数,也就是说,他把加法和求和杂合在一起做了。(传统的办法是先做乘法,然后在合并同类项的时候才作加法)
  以x*x的系数为例,得到x*x,或者是用x*x乘5,或者是用3x乘2x,也就是
  2 3 1
  _ 2 5
  -----
   6+5=11
  其实,这正是向量的内积.如此则,卷积运算,可以看作是一串内积运算.既然是一串内积运算,则我们可以试图用矩阵表示上述过程。
  
  [ 2 3 1 0 0 0]
  [ 0 2 3 1 0 0]==A
  [ 0 0 2 3 1 0]
  [ 0 0 0 2 3 1]
  
  [0 0 2 5 0 0]' == x
  
  b= Ax=[ 2 11 19 10]'
  
  采用行的观点看Ax,则b的每行都是一个内积。
  A的每一行都是序列[2 3 1]的一个移动位置。
  
  ---------
  
  显然,在这个特定的背景下,我们知道,卷积满足交换,结合等定律,因为,众所周知的,多项式的乘法满足交换律,结合律.在一般情形下,其实也成立.
  
  在这里,我们发现多项式,除了构成特定的线性空间外,基与基之间还存在某种特殊的联系,正是这种联系,给予多项式空间以特殊的性质.
  
  在学向量的时候,一般都会举这个例子,甲有三个苹果,5个橘子,乙有5个苹果,三个橘子,则共有几个苹果,橘子。老师反复告诫,橘子就是橘子,苹果就是苹果,可不能混在一起。所以有(3,5)+(5,3)=(8,8).是的,橘子和苹果无论怎么加,都不会出什么问题的,但是,如果考虑橘子乘橘子,或者橘子乘苹果,这问题就不大容易说清了。
  
  又如复数,如果仅仅定义复数为数对(a,b),仅仅在线性空间的层面看待C2,那就未免太简单了。实际上,只要加上一条(a,b)*(c,d)=(ac-bd,ad+bc)
  则情况马上改观,复变函数的内容多么丰富多彩,是众所周知的。
  
  另外,回想信号处理里面的一条基本定理,频率域的乘积,相当于时域或空域信号的卷积.恰好跟这里的情形完全对等.这后面存在什么样的隐态联系,需要继续参详.
  
  从这里看,高等的卷积运算其实不过是一种初等的运算的抽象而已.中学学过的数学里面,其实还蕴涵着许多高深的内容(比如交换代数)。温故而知新,斯言不谬.
  
  其实这道理一点也不复杂,人类繁衍了多少万年了,但过去n多年,人们只知道男女媾精,乃能繁衍后代。精子,卵子的发现,生殖机制的研究,也就是最近多少年的事情。
  
  孔子说,道在人伦日用中,看来我们应该多用审视的眼光看待周围,乃至自身,才能知其然,而知其所以然。


----------------------------------------------------------完毕------------------------------


然后我们就知道卷积大概的作用了。

那么FFT本来是信号里面的东西,而我没学过信号。 所以看的也不怎么懂。

大概就是对离散的信号,先将其转变为一些正弦函数,然后这些正弦函数叠加能构成这个离散信号,但是这些正弦函数易于处理。处理完之后就可以再转变回来。

两个过程叫做DFT和IDFT。



对于本道题。意义就很明显了。

可以把两个大整数相乘看做是多项式乘法。

最后求出各系数后再进位即可


代码如下、

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define L(x) (1 << (x))
const double PI = acos(-1.0);
const int Maxn = 133015;
double ax[Maxn], ay[Maxn], bx[Maxn], by[Maxn];
char sa[Maxn/2],sb[Maxn/2];
int sum[Maxn];
int x1[Maxn],x2[Maxn];
int revv(int x, int bits)
{
    int ret = 0;
    for (int i = 0; i < bits; i++)
    {
        ret <<= 1;
        ret |= x & 1;
        x >>= 1;
    }
    return ret;
}
void fft(double * a, double * b, int n, bool rev)
{
    int bits = 0;
    while (1 << bits < n) ++bits;
    for (int i = 0; i < n; i++)
    {
        int j = revv(i, bits);
        if (i < j)
            swap(a[i], a[j]), swap(b[i], b[j]);
    }
    for (int len = 2; len <= n; len <<= 1)
    {
        int half = len >> 1;
        double wmx = cos(2 * PI / len), wmy = sin(2 * PI / len);
        if (rev) wmy = -wmy;
        for (int i = 0; i < n; i += len)
        {
            double wx = 1, wy = 0;
            for (int j = 0; j < half; j++)
            {
                double cx = a[i + j], cy = b[i + j];
                double dx = a[i + j + half], dy = b[i + j + half];
                double ex = dx * wx - dy * wy, ey = dx * wy + dy * wx;
                a[i + j] = cx + ex, b[i + j] = cy + ey;
                a[i + j + half] = cx - ex, b[i + j + half] = cy - ey;
                double wnx = wx * wmx - wy * wmy, wny = wx * wmy + wy * wmx;
                wx = wnx, wy = wny;
            }
        }
    }
    if (rev)
    {
        for (int i = 0; i < n; i++)
            a[i] /= n, b[i] /= n;
    }
}
int solve(int a[],int na,int b[],int nb,int ans[])
{
    int len = max(na, nb), ln;
    for(ln=0; L(ln)<len; ++ln);
    len=L(++ln);
    for (int i = 0; i < len ; ++i)
    {
        if (i >= na) ax[i] = 0, ay[i] =0;
        else ax[i] = a[i], ay[i] = 0;
    }
    fft(ax, ay, len, 0);
    for (int i = 0; i < len; ++i)
    {
        if (i >= nb) bx[i] = 0, by[i] = 0;
        else bx[i] = b[i], by[i] = 0;
    }
    fft(bx, by, len, 0);
    for (int i = 0; i < len; ++i)
    {
        double cx = ax[i] * bx[i] - ay[i] * by[i];
        double cy = ax[i] * by[i] + ay[i] * bx[i];
        ax[i] = cx, ay[i] = cy;
    }
    fft(ax, ay, len, 1);
    for (int i = 0; i < len; ++i)
        ans[i] = (int)(ax[i] + 0.5);
    return len;
}

int main()
{
    int l1,l2,l;
    int i;
    while(gets(sa))
    {
        gets(sb);
        memset(sum, 0, sizeof(sum));
        l1 = strlen(sa);
        l2 = strlen(sb);
        for(i = 0; i < l1; i++)
            x1[i] = sa[l1 - i - 1]-'0';
        for(i = 0; i < l2; i++)
            x2[i] = sb[l2-i-1]-'0';
        l = solve(x1, l1, x2, l2, sum);
        for(i = 0; i<l || sum[i] >= 10; i++) // 进位
        {
            sum[i + 1] += sum[i] / 10;
            sum[i] %= 10;
        }
        l = i;
        while(sum[l] <= 0 && l>0)    l--; // 检索最高位
        for(i = l; i >= 0; i--)    putchar(sum[i] + '0'); // 倒序输出
        putchar('\n');
    }
    return 0;
}



然后模板来一发。


#define L(x) (1 << (x))
const double PI = acos(-1.0);
const int Maxn = 133015;
double ax[Maxn], ay[Maxn], bx[Maxn], by[Maxn];
int revv(int x, int bits)
{
    int ret = 0;
    for (int i = 0; i < bits; i++)
    {
        ret <<= 1;
        ret |= x & 1;
        x >>= 1;
    }
    return ret;
}
void fft(double * a, double * b, int n, bool rev)
{
    int bits = 0;
    while (1 << bits < n) ++bits;
    for (int i = 0; i < n; i++)
    {
        int j = revv(i, bits);
        if (i < j)
            swap(a[i], a[j]), swap(b[i], b[j]);
    }
    for (int len = 2; len <= n; len <<= 1)
    {
        int half = len >> 1;
        double wmx = cos(2 * PI / len), wmy = sin(2 * PI / len);
        if (rev) wmy = -wmy;
        for (int i = 0; i < n; i += len)
        {
            double wx = 1, wy = 0;
            for (int j = 0; j < half; j++)
            {
                double cx = a[i + j], cy = b[i + j];
                double dx = a[i + j + half], dy = b[i + j + half];
                double ex = dx * wx - dy * wy, ey = dx * wy + dy * wx;
                a[i + j] = cx + ex, b[i + j] = cy + ey;
                a[i + j + half] = cx - ex, b[i + j + half] = cy - ey;
                double wnx = wx * wmx - wy * wmy, wny = wx * wmy + wy * wmx;
                wx = wnx, wy = wny;
            }
        }
    }
    if (rev)
    {
        for (int i = 0; i < n; i++)
            a[i] /= n, b[i] /= n;
    }
}
int solve(int a[],int na,int b[],int nb,int ans[]) //两个数组求卷积,有时ans数组要开成long long
{
    int len = max(na, nb), ln;
    for(ln=0; L(ln)<len; ++ln);
    len=L(++ln);
    for (int i = 0; i < len ; ++i)
    {
        if (i >= na) ax[i] = 0, ay[i] =0;
        else ax[i] = a[i], ay[i] = 0;
    }
    fft(ax, ay, len, 0);
    for (int i = 0; i < len; ++i)
    {
        if (i >= nb) bx[i] = 0, by[i] = 0;
        else bx[i] = b[i], by[i] = 0;
    }
    fft(bx, by, len, 0);
    for (int i = 0; i < len; ++i)
    {
        double cx = ax[i] * bx[i] - ay[i] * by[i];
        double cy = ax[i] * by[i] + ay[i] * bx[i];
        ax[i] = cx, ay[i] = cy;
    }
    fft(ax, ay, len, 1);
    for (int i = 0; i < len; ++i)
        ans[i] = (int)(ax[i] + 0.5);
    return len;
}
int solve(long long a[], int na, int ans[]) //自己跟自己求卷积,有时候ans数组要开成long long
{
    int len = na, ln;
    for(ln = 0; L(ln) < na; ++ln);
    len=L(++ln);
    for(int i = 0; i < len; ++i)
    {
        if (i >= na) ax[i] = 0, ay[i] = 0;
        else ax[i] = a[i], ay[i] = 0;
    }
    fft(ax, ay, len, 0);
    for(int i=0; i<len; ++i)
    {
        double cx = ax[i] * ax[i] - ay[i] * ay[i];
        double cy = 2 * ax[i] * ay[i];
        ax[i] = cx, ay[i] = cy;
    }
    fft(ax, ay, len, 1);

    for(int i=0; i<len; ++i)
        ans[i] = ax[i] + 0.5;
    return len;
}


你可能感兴趣的:(HDU 1402 FFT 求 大数乘法)