快速傅里叶变换

tkp2014

关注

转载最新推荐文章于 2026-09-16 16:02:13 发布 686 阅读 AI 写同款· GEO 优化 ›

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1402

　　一般的的大数乘法都是直接模拟乘法演算过程，复杂度O(n^2)，对于这题来说会超时。乘法的过程基本就是等同于多项式相乘的过程，只是没有进位而已。对于这种问题我们需要转化然后用FFT求解。FFT是用来计算离散傅里叶变化(DFT)及其逆变换(IDFT)的快速算法，复杂度O(n*logn)。DFT有一个很重要的性质：时域卷积，频域乘积；频域乘积，时域卷积。

时域、频域、卷积、乘积呢？

时域和频域是两种信号的分析方法，DFT可以把时域信号变化为频域信号。卷积就是作多项式乘法，乘积就是依次乘过去。如果单纯的用多项式表示法进行乘法运算，那么基本就没有优化的地方了，

此时我们换一种多项式的表示方法：点值法。表示的就是n个“点-值”对的序列{(x0,y0),(x1,y1),...,(xn-1,yn-1)}，yk满足yk=A(xk)，A()多项式函数，其中xk的值是随便取的。

点值法非常适合作乘法，只需要把对应位置的值乘起来就可以了，复杂度O(n)，其实就是做一次乘积，前面的多项式是做一次卷积。那么我们的重点就是怎样快速的把多项式转换为“点值”表示法，如果单纯的带值进去，那么复杂度就是O(n^2)，这个时候FFT就派上用场了，可以在O(n*logn)的时间内求出来。

　　FFT用到了单位复根的概念，n次单位复根就是满足w^n=1的复数，n次单位复根刚好有n个：e^(2*PI*i*k/n),k=0,1,...,n-1，其中有e^(i*u)=cos(u)+i*sin(u)。n次单位复根有如下的一些引理：

　　　　1.相消引理：对于任何整数n>=0,k>=0,d>0,有。

　　　　2.折半引理：如果n>0为偶数，n个n次的单位复根的平方等于n/2个n/2次单位复根。公式表示为：。

　　FFT主要是用到了折半引理，对多项式进行分治运算，它用A(x)中偶数下标的系数与奇数下标的系数，分别定义了两个新的次数为n/2的多项式A[0](x)和A[1](x)：

　　　　A[0](x) = a0 + a2x + a4x^4 + ... +an-2x^(n/2-1)
　　　　A[1](x) = a1 + a3x + a5x^4 + ... +an-1x^(n/2-1)

　　那么A(x) = A[0](x^2) + xA[1](x^2)。

　　我们把点值法中x0,x1,...,xn-1的值分别设为，根据折半引理，值的序列并不是由n个不同的值组成的，而是由n/2个n/2次单位复根所组成，每个根出现两次，那么我们就可以对表达式递归的求值了，复杂度O(nlogn)。把多项式用"点值”法表示的问题解决了，然后做一遍乘积就行了。最后就是把“点值”法求的一个向量f求逆就可以了，对应的过程就是IDFT，思想也是差不多的。。。

FFT算法

  1 //STATUS:G++_AC_171MS_7128KB
  2 #include <functional>
  3 #include <algorithm>
  4 #include <iostream>
  5 //#include <ext/rope>
  6 #include <fstream>
  7 #include <sstream>
  8 #include <iomanip>
  9 #include <numeric>
 10 #include <cstring>
 11 #include <cassert>
 12 #include <cstdio>
 13 #include <string>
 14 #include <vector>
 15 #include <bitset>
 16 #include <queue>
 17 #include <stack>
 18 #include <cmath>
 19 #include <ctime>
 20 #include <list>
 21 #include <set>
 22 #include <map>
 23 using namespace std;
 24 //#pragma comment(linker,"/STACK:102400000,102400000")
 25 //using namespace __gnu_cxx;
 26 //define
 27 #define pii pair<int,int>
 28 #define mem(a,b) memset(a,b,sizeof(a))
 29 #define lson l,mid,rt<<1
 30 #define rson mid+1,r,rt<<1|1
 31 #define PI acos(-1.0)
 32 //typedef
 33 typedef __int64 LL;
 34 typedef unsigned __int64 ULL;
 35 //const
 36 const int N=200010;
 37 const int INF=0x3f3f3f3f;
 38 const int MOD=10007,STA=8000010;
 39 const LL LNF=1LL<<55;
 40 const double EPS=1e-4;
 41 const double OO=1e30;
 42 const int dx[4]={-1,0,1,0};
 43 const int dy[4]={0,1,0,-1};
 44 const int day[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
 45 //Daily Use ...
 46 inline int sign(double x){return (x>EPS)-(x<-EPS);}
 47 template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}
 48 template<class T> T lcm(T a,T b){return a/gcd(a,b)*b;}
 49 template<class T> inline T lcm(T a,T b,T d){return a/d*b;}
 50 template<class T> inline T Min(T a,T b){return a<b?a:b;}
 51 template<class T> inline T Max(T a,T b){return a>b?a:b;}
 52 template<class T> inline T Min(T a,T b,T c){return min(min(a, b),c);}
 53 template<class T> inline T Max(T a,T b,T c){return max(max(a, b),c);}
 54 template<class T> inline T Min(T a,T b,T c,T d){return min(min(a, b),min(c,d));}
 55 template<class T> inline T Max(T a,T b,T c,T d){return max(max(a, b),max(c,d));}
 56 //End
 57 //复数结构体
 58 struct complex
 59 {
 60     double r,i;
 61     complex(double _r = 0.0,double _i = 0.0)
 62     {
 63         r = _r; i = _i;
 64     }
 65     complex operator +(const complex &b)
 66     {
 67         return complex(r+b.r,i+b.i);
 68     }
 69     complex operator -(const complex &b)
 70     {
 71         return complex(r-b.r,i-b.i);
 72     }
 73     complex operator *(const complex &b)
 74     {
 75         return complex(r*b.r-i*b.i,r*b.i+i*b.r);
 76     }
 77 };
 78 /*
 79  * 进行FFT和IFFT前的反转变换。
 80  * 位置i和 （i二进制反转后位置）互换
 81  * len必须去2的幂
 82  */
 83 void change(complex y[],int len)
 84 {
 85     int i,j,k;
 86     for(i = 1, j = len/2;i < len-1; i++)
 87     {
 88         if(i < j)swap(y[i],y[j]);
 89         //交换互为小标反转的元素，i<j保证交换一次
 90         //i做正常的+1，j左反转类型的+1,始终保持i和j是反转的
 91         k = len/2;
 92         while( j >= k)
 93         {
 94             j -= k;
 95             k /= 2;
 96         }
 97         if(j < k) j += k;
 98     }
 99 }
100 /*
101  * 做FFT
102  * len必须为2^k形式，
103  * on==1时是DFT，on==-1时是IDFT
104  */
105 void FFT(complex y[],int len,int on)
106 {
107     change(y,len);
108     for(int h = 2; h <= len; h <<= 1)
109     {
110         complex wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
111         for(int j = 0;j < len;j+=h)
112         {
113             complex w(1,0);
114             for(int k = j;k < j+h/2;k++)
115             {
116                 complex u = y[k];
117                 complex t = w*y[k+h/2];
118                 y[k] = u+t;
119                 y[k+h/2] = u-t;
120                 w = w*wn;
121             }
122         }
123     }
124     if(on == -1)
125         for(int i = 0;i < len;i++)
126             y[i].r /= len;
127 }
128 
129 char s1[N],s2[N];
130 int ans[N];
131 complex a[N],b[N];
132 
133 int main(){
134   //  freopen("in.txt","r",stdin);
135     int i,j,len1,len2,len;
136     while(~scanf("%s%s",s1,s2))
137     {
138         len1=strlen(s1);
139         len2=strlen(s2);
140         len=1;
141         while(len<(len1<<1) || len<(len2<<1))len<<=1;
142         for(i=0;i<len1;i++)a[i]=complex(s1[len1-i-1]-'0',0);
143         for(;i<len;i++)a[i]=complex(0,0);
144         for(i=0;i<len2;i++)b[i]=complex(s2[len2-i-1]-'0',0);
145         for(;i<len;i++)b[i]=complex(0,0);
146 
147         FFT(a,len,1);
148         FFT(b,len,1);
149         for(i=0;i<len;i++)a[i]=a[i]*b[i];
150         FFT(a,len,-1);
151         for(i=0;i<len;i++)ans[i]=(int)(a[i].r+0.5);
152         len=len1+len2-1;
153         for(i=0;i<len;i++){
154             ans[i+1]+=ans[i]/10;
155             ans[i]%=10;
156         }
157         for(i=len;ans[i]<=0 && i>0;i--);
158         for(;i>=0;i--)
159             printf("%d",ans[i]);
160         putchar('\n');
161     }
162     return 0;
163 }