BZOJ 2179 FFT快速傅立叶 题解

bzoj 2179

Description
给出两个n位10进制整数x和y，你需要计算x*y。

---

【题目分析】

高精裸题。练手。

【代码】

1、手动高精

 #include<cstdio>
 #include<cstring>
 using namespace std;
 #define MAXN 5000
 char a_s[MAXN],b_s[MAXN];
 int a_len,b_len,i,c[MAXN][MAXN],k,j,sum[MAXN],a[MAXN],b[MAXN];
 int sumlen()
 {
     int nu=;
     for(int ii=a_len+b_len;ii>=;ii--)
         if(sum[ii])break;
         else nu++;
     return a_len+b_len-nu;
 }
 int main()
 {
     int n;cin>>n;
     scanf("%s%s",&a_s,&b_s);
     if(!strcmp(a_s,"")||!strcmp(b_s,"")){printf("0\n");return ;}
     memset(a,,sizeof(a));
     memset(b,,sizeof(b));
     a_len=strlen(a_s);
     b_len=strlen(b_s);
     for(i=;i<a_len;i++)a[a_len-i]=a_s[i]-'';
     for(i=;i<b_len;i++)b[b_len-i]=b_s[i]-'';
     memset(c,,sizeof(c));
     for(i=;i<=b_len;i++)
     {
         k=;
         for(j=;j<=a_len;j++)
         {
             c[i][j+i-]=a[j]*b[i]+k;
             k=c[i][j+i-]/;
             c[i][j+i-]%=;
         }
         c[i][a_len+i]+=k;
     }
     memset(sum,,sizeof(sum));
     for(i=;i<=b_len;i++)
     {
         k=;
         for(j=;j<=a_len+b_len;j++)
         {
             sum[j]=sum[j]+c[i][j]+k;
             k=sum[j]/;
             sum[j]%=;
         }
         sum[sumlen()+]+=k;
     }
     for(i=sumlen();i>=;i--)printf("%d",sum[i]);
     putchar('\n');
     return ;
 }

手动高精

2、重载运算符

 #include<iostream>
 #include<string>
 #include<iomanip>
 #include<algorithm>
 using namespace std; 

 #define MAXN 9999
 #define MAXSIZE 10
 #define DLEN 4

 class BigNum
 {
 private:
     int a[];    //可以控制大数的位数
     int len;       //大数长度
 public:
     BigNum(){ len = ;memset(a,,sizeof(a)); }   //构造函数
     BigNum(const int);       //将一个int类型的变量转化为大数
     BigNum(const char*);     //将一个字符串类型的变量转化为大数
     BigNum(const BigNum &);  //拷贝构造函数
     BigNum &operator=(const BigNum &);   //重载赋值运算符，大数之间进行赋值运算

     friend istream& operator>>(istream&,  BigNum&);   //重载输入运算符
     friend ostream& operator<<(ostream&,  BigNum&);   //重载输出运算符

     BigNum operator+(const BigNum &) const;   //重载加法运算符，两个大数之间的相加运算
     BigNum operator-(const BigNum &) const;   //重载减法运算符，两个大数之间的相减运算
     BigNum operator*(const BigNum &) const;   //重载乘法运算符，两个大数之间的相乘运算
     BigNum operator/(const int   &) const;    //重载除法运算符，大数对一个整数进行相除运算

     BigNum operator^(const int  &) const;    //大数的n次方运算
     int    operator%(const int  &) const;    //大数对一个int类型的变量进行取模运算
     bool   operator>(const BigNum & T)const;   //大数和另一个大数的大小比较
     bool   operator>(const int & t)const;      //大数和一个int类型的变量的大小比较

     void print();       //输出大数
 };
 BigNum::BigNum(const int b)     //将一个int类型的变量转化为大数
 {
     int c,d = b;
     len = ;
     memset(a,,sizeof(a));
     while(d > MAXN)
     {
         c = d - (d / (MAXN + )) * (MAXN + );
         d = d / (MAXN + );
         a[len++] = c;
     }
     a[len++] = d;
 }
 BigNum::BigNum(const char*s)     //将一个字符串类型的变量转化为大数
 {
     int t,k,index,l,i;
     memset(a,,sizeof(a));
     l=strlen(s);
     len=l/DLEN;
     if(l%DLEN)
         len++;
     index=;
     for(i=l-;i>=;i-=DLEN)
     {
         t=;
         k=i-DLEN+;
         if(k<)
             k=;
         for(int j=k;j<=i;j++)
             t=t*+s[j]-'';
         a[index++]=t;
     }
 }
 BigNum::BigNum(const BigNum & T) : len(T.len)  //拷贝构造函数
 {
     int i;
     memset(a,,sizeof(a));
     for(i =  ; i < len ; i++)
         a[i] = T.a[i];
 }
 BigNum & BigNum::operator=(const BigNum & n)   //重载赋值运算符，大数之间进行赋值运算
 {
     int i;
     len = n.len;
     memset(a,,sizeof(a));
     for(i =  ; i < len ; i++)
         a[i] = n.a[i];
     return *this;
 }
 istream& operator>>(istream & in,  BigNum & b)   //重载输入运算符
 {
     char ch[MAXSIZE*];
     int i = -;
     in>>ch;
     int l=strlen(ch);
     int count=,sum=;
     for(i=l-;i>=;)
     {
         sum = ;
         int t=;
         for(int j=;j<&&i>=;j++,i--,t*=)
         {
             sum+=(ch[i]-'')*t;
         }
         b.a[count]=sum;
         count++;
     }
     b.len =count++;
     return in;

 }
 ostream& operator<<(ostream& out,  BigNum& b)   //重载输出运算符
 {
     int i;
     cout << b.a[b.len - ];
     for(i = b.len -  ; i >=  ; i--)
     {
         cout.width(DLEN);
         cout.fill('');
         cout << b.a[i];
     }
     return out;
 }

 BigNum BigNum::operator+(const BigNum & T) const   //两个大数之间的相加运算
 {
     BigNum t(*this);
     int i,big;      //位数
     big = T.len > len ? T.len : len;
     for(i =  ; i < big ; i++)
     {
         t.a[i] +=T.a[i];
         if(t.a[i] > MAXN)
         {
             t.a[i + ]++;
             t.a[i] -=MAXN+;
         }
     }
     if(t.a[big] != )
         t.len = big + ;
     else
         t.len = big;
     return t;
 }
 BigNum BigNum::operator-(const BigNum & T) const   //两个大数之间的相减运算
 {
     int i,j,big;
     bool flag;
     BigNum t1,t2;
     if(*this>T)
     {
         t1=*this;
         t2=T;
         flag=;
     }
     else
     {
         t1=T;
         t2=*this;
         flag=;
     }
     big=t1.len;
     for(i =  ; i < big ; i++)
     {
         if(t1.a[i] < t2.a[i])
         {
             j = i + ;
             while(t1.a[j] == )
                 j++;
             t1.a[j--]--;
             while(j > i)
                 t1.a[j--] += MAXN;
             t1.a[i] += MAXN +  - t2.a[i];
         }
         else
             t1.a[i] -= t2.a[i];
     }
     t1.len = big;
     while(t1.a[len - ] ==  && t1.len > )
     {
         t1.len--;
         big--;
     }
     if(flag)
         t1.a[big-]=-t1.a[big-];
     return t1;
 } 

 BigNum BigNum::operator*(const BigNum & T) const   //两个大数之间的相乘运算
 {
     BigNum ret;
     int i,j,up;
     int temp,temp1;
     for(i =  ; i < len ; i++)
     {
         up = ;
         for(j =  ; j < T.len ; j++)
         {
             temp = a[i] * T.a[j] + ret.a[i + j] + up;
             if(temp > MAXN)
             {
                 temp1 = temp - temp / (MAXN + ) * (MAXN + );
                 up = temp / (MAXN + );
                 ret.a[i + j] = temp1;
             }
             else
             {
                 up = ;
                 ret.a[i + j] = temp;
             }
         }
         if(up != )
             ret.a[i + j] = up;
     }
     ret.len = i + j;
     while(ret.a[ret.len - ] ==  && ret.len > )
         ret.len--;
     return ret;
 }
 BigNum BigNum::operator/(const int & b) const   //大数对一个整数进行相除运算
 {
     BigNum ret;
     int i,down = ;
     for(i = len -  ; i >=  ; i--)
     {
         ret.a[i] = (a[i] + down * (MAXN + )) / b;
         down = a[i] + down * (MAXN + ) - ret.a[i] * b;
     }
     ret.len = len;
     while(ret.a[ret.len - ] ==  && ret.len > )
         ret.len--;
     return ret;
 }
 int BigNum::operator %(const int & b) const    //大数对一个int类型的变量进行取模运算
 {
     int i,d=;
     for (i = len-; i>=; i--)
     {
         d = ((d * (MAXN+))% b + a[i])% b;
     }
     return d;
 }
 BigNum BigNum::operator^(const int & n) const    //大数的n次方运算
 {
     BigNum t,ret();
     int i;
     if(n<)
         exit(-);
     if(n==)
         return ;
     if(n==)
         return *this;
     int m=n;
     while(m>)
     {
         t=*this;
         for( i=;i<<<=m;i<<=)
         {
             t=t*t;
         }
         m-=i;
         ret=ret*t;
         if(m==)
             ret=ret*(*this);
     }
     return ret;
 }
 bool BigNum::operator>(const BigNum & T) const   //大数和另一个大数的大小比较
 {
     int ln;
     if(len > T.len)
         return true;
     else if(len == T.len)
     {
         ln = len - ;
         while(a[ln] == T.a[ln] && ln >= )
             ln--;
         if(ln >=  && a[ln] > T.a[ln])
             return true;
         else
             return false;
     }
     else
         return false;
 }
 bool BigNum::operator >(const int & t) const    //大数和一个int类型的变量的大小比较
 {
     BigNum b(t);
     return *this>b;
 }

 void BigNum::print()    //输出大数
 {
     int i;
     cout << a[len - ];
     for(i = len -  ; i >=  ; i--)
     {
         cout.width(DLEN);
         cout.fill('');
         cout << a[i];
     }
     cout << endl;
 }
 int main(void)
 {
     int i,n;
     BigNum x，y;      //定义大数的对象数组
     cin>>n;
                 cin>>x>>y;
                 x=x*y;
     x.print();
                 return ;
 }

重载运算符

3、快速傅里叶变换（FFT）{p.s.其实并不会。有一位巨神提供的代码。以后慢慢学。}

 #include<bits/stdc++.h>
 using namespace std;
 const double pi=acos(-1.0);
 int rev[],ans[],len,n,m;
 char s[];
 struct P
 {
     double x,y;
     inline P operator +(P a) {return (P){x+a.x,y+a.y};}
     inline P operator -(P a) {return (P){x-a.x,y-a.y};}
     inline P operator *(P a) {return (P){x*a.x-y*a.y,x*a.y+y*a.x};}
 }a[],b[],c[];
 inline void fft(P *x,int n,int flag)//快速傅立叶变换
 {
     for (int i=;i<n;++i) if (rev[i]>i) swap(x[rev[i]],x[i]);
     for(int m=;m<=n;m<<=)
     {
         P wn=(P){cos(2.0*pi/m*flag),sin(2.0*pi/m*flag)};
         for(int i=;i<n;i+=m)
         {
             P w=(P){1.0,};int mid=m>>;
             for (int j=;j<mid;++j)
             {
                 P u=x[i+j],v=x[i+j+mid]*w;
                 x[i+j]=u+v;x[i+j+mid]=u-v;
                 w=w*wn;
             }
         }
     }
 }
 int main()
 {
     scanf("%d",&n);
     scanf("%s",s);for (int i=;i<n;++i) a[i].x=s[n-i-]-'';
     scanf("%s",s);for (int i=;i<n;++i) b[i].x=s[n-i-]-'';
     m=;n=n*-;
     while (m<=n) m<<=,len++; n=m;
     for (int i=;i<n;++i)
     {
         int t=i,ret=;
         for (int j=;j<=len;++j) ret<<=,ret|=t&,t>>=;
         rev[i]=ret;
     }
     fft(a,n,);fft(b,n,);//转过去
     for (int i=;i<n;++i) c[i]=a[i]*b[i];//高效率高精度
     fft(c,n,-);//又回来
     for (int i=;i<n;++i) ans[i]=(c[i].x/n)+0.5;//精度误差
     for (int i=;i<n;++i) ans[i+]+=ans[i]/,ans[i]%=;//进位
     n++;
     while (!ans[n]&&n) n--;//确定第一个数的位置
     for (int i=n;i>=;--i) putchar(ans[i]+'');//输出
 }

FFT