ACM-高精度模板(综合篇)

时间：-- ::      阅读：      评论：      收藏：      [点我收藏+]

标签：高精度

在这里，我们约定，能用int表示的数据视为单精度，否则为高精度。所有函数的设计均采用带返回值的形式。

本文包含

.高精度加法

.高精度减法

.高精度乘法

）高精度乘高精度的朴素算法

）高精度乘高精度FFT优化算法

）高精度乘单精度

.高精度除法

）高精度除高精度

）高精度除单精度

.高精度取模

）高精度对高精度取模

）高精度对单精度取模

.高精度阶乘

.高精度幂

.高精度GCD

.高精度进制转换

下面切入正题

.高精度加法

传入参数约定：传入参数均为string类型，返回值为string类型

算法思想：倒置相加再还原。

算法复杂度：o(n)

#include<iostream>

#include<cstring>

#include<algorithm>

using namespace std;

const int L=;

string add(string a,string b)//只限两个非负整数相加

{

    string ans;

    int na[L]={},nb[L]={};

    int la=a.size(),lb=b.size();

    for(int i=;i<la;i++) na[la--i]=a[i]-'';

    for(int i=;i<lb;i++) nb[lb--i]=b[i]-'';

    int lmax=la>lb?la:lb;

    for(int i=;i<lmax;i++) na[i]+=nb[i],na[i+]+=na[i]/,na[i]%=;

    if(na[lmax]) lmax++;

    for(int i=lmax-;i>=;i--) ans+=na[i]+'';

    return ans;

}

int main()

{

    string a,b;

    while(cin>>a>>b) cout<<add(a,b)<<endl;

    return ;

}

.高精度减法

传入参数约定：传入参数均为string类型，返回值为string类型

算法思想：倒置相减再还原。

算法复杂度：o(n)

#include<iostream>

#include<cstring>

#include<algorithm>

using namespace std;

const int L=;

string sub(string a,string b)//只限大的非负整数减小的非负整数

{

    string ans;

    int na[L]={},nb[L]={};

    int la=a.size(),lb=b.size();

    for(int i=;i<la;i++) na[la--i]=a[i]-'';

    for(int i=;i<lb;i++) nb[lb--i]=b[i]-'';

    int lmax=la>lb?la:lb;

    for(int i=;i<lmax;i++)

    {

        na[i]-=nb[i];

        if(na[i]<) na[i]+=,na[i+]--;

    }

    while(!na[--lmax]&&lmax>)  ;lmax++;

    for(int i=lmax-;i>=;i--) ans+=na[i]+'';

    return ans;

}

int main()

{

    string a,b;

    while(cin>>a>>b) cout<<sub(a,b)<<endl;

    return ;

}

.高精度乘法

）高精度乘高精度的朴素算法

传入参数约定：传入参数均为string类型，返回值为string类型

算法思想：倒置相乘，然后统一处理进位，再还原。

算法复杂度：o(n^)

#include<iostream>

#include<cstring>

#include<algorithm>

using namespace std;

const int L=;

string mul(string a,string b)//高精度乘法a,b,均为非负整数

{

    string s;

    int na[L],nb[L],nc[L],La=a.size(),Lb=b.size();//na存储被乘数，nb存储乘数，nc存储积

    fill(na,na+L,);fill(nb,nb+L,);fill(nc,nc+L,);//将na,nb,nc都置为0

    for(int i=La-;i>=;i--) na[La-i]=a[i]-'';//将字符串表示的大整形数转成i整形数组表示的大整形数

    for(int i=Lb-;i>=;i--) nb[Lb-i]=b[i]-'';

    for(int i=;i<=La;i++)

        for(int j=;j<=Lb;j++)

        nc[i+j-]+=na[i]*nb[j];//a的第i位乘以b的第j位为积的第i+j-1位（先不考虑进位）

    for(int i=;i<=La+Lb;i++)

        nc[i+]+=nc[i]/,nc[i]%=;//统一处理进位

    if(nc[La+Lb]) s+=nc[La+Lb]+'';//判断第i+j位上的数字是不是0

    for(int i=La+Lb-;i>=;i--)

        s+=nc[i]+'';//将整形数组转成字符串

    return s;

}

int main()

{

    string a,b;

    while(cin>>a>>b) cout<<mul(a,b)<<endl;

    return ;

}

）高精度乘高精度FFT优化算法

传入参数约定：传入参数均为string类型，返回值为string类型

算法思想：将两个高精度乘数每个数位上的数视为多项式对应的系数，用o(n*log(n))的复杂度转成点值形式，再利用o(n)的复杂度相乘，最后对点值进行差值，用o(n*log(n))的复杂度还原成多项式的形式，即原来的形式。

算法复杂度：o(n*log(n))

#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 = ;

double ax[Maxn], ay[Maxn], bx[Maxn], by[Maxn];

char sa[Maxn/],sb[Maxn/];

int sum[Maxn];

int x1[Maxn],x2[Maxn];

int revv(int x, int bits)

{

    int ret = ;

    for (int i = ; i < bits; i++)

    {

        ret <<= ;

        ret |= x & ;

        x >>= ;

    }

    return ret;

}

void fft(double * a, double * b, int n, bool rev)

{

    int bits = ;

    while ( << bits < n) ++bits;

    for (int i = ; i < n; i++)

    {

        int j = revv(i, bits);

        if (i < j)

            swap(a[i], a[j]), swap(b[i], b[j]);

    }

    for (int len = ; len <= n; len <<= )

    {

        int half = len >> ;

        double wmx = cos( * PI / len), wmy = sin( * PI / len);

        if (rev) wmy = -wmy;

        for (int i = ; i < n; i += len)

        {

            double wx = , wy = ;

            for (int j = ; 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 = ; 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=; L(ln)<len; ++ln);

    len=L(++ln);

    for (int i = ; i < len ; ++i)

    {

        if (i >= na) ax[i] = , ay[i] =;

        else ax[i] = a[i], ay[i] = ;

    }

    fft(ax, ay, len, );

    for (int i = ; i < len; ++i)

    {

        if (i >= nb) bx[i] = , by[i] = ;

        else bx[i] = b[i], by[i] = ;

    }

    fft(bx, by, len, );

    for (int i = ; 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, );

    for (int i = ; i < len; ++i)

        ans[i] = (int)(ax[i] + 0.5);

    return len;

}

string mul(string sa,string sb)

{

    int l1,l2,l;

    int i;

    string ans;

    memset(sum, , sizeof(sum));

    l1 = sa.size();

    l2 = sb.size();

    for(i = ; i < l1; i++)

        x1[i] = sa[l1 - i - ]-'';

    for(i = ; i < l2; i++)

        x2[i] = sb[l2-i-]-'';

    l = solve(x1, l1, x2, l2, sum);

    for(i = ; i<l || sum[i] >= ; i++) // 进位

    {

        sum[i + ] += sum[i] / ;

        sum[i] %= ;

    }

    l = i;

    while(sum[l] <=  && l>)    l--; // 检索最高位

    for(i = l; i >= ; i--)    ans+=sum[i] + ''; // 倒序输出

    return ans;

}

int main()

{

    cin.sync_with_stdio(false);

    string a,b;

    while(cin>>a>>b) cout<<mul(a,b)<<endl;

    return ;

}

）高精度乘单精度

传入参数约定：传入第一个参数为string类型，，第二个参数为int型，返回值为string类型

算法思想：倒置相乘，然后统一处理进位，再还原。

算法复杂度：o(n)

#include<iostream>

#include<cstring>

#include<algorithm>

using namespace std;

const int L=;

int na[L];

string mul(string a,int b)//高精度a乘单精度b

{

    string ans;

    int La=a.size();

    fill(na,na+L,);

    for(int i=La-;i>=;i--) na[La-i-]=a[i]-'';

    int w=;

    for(int i=;i<La;i++) na[i]=na[i]*b+w,w=na[i]/,na[i]=na[i]%;

    while(w) na[La++]=w%,w/=;

    La--;

    while(La>=) ans+=na[La--]+'';

    return ans;

}

int main()

{

    string a;

    int b;

    while(cin>>a>>b) cout<<mul(a,b)<<endl;

    return ;

}

.高精度除法

）高精度除高精度

传入参数约定：传入第一第二个参数均为string类型，第三个为int型，返回值为string类型

算法思想：倒置，试商，高精度减法。

算法复杂度：o(n^)

#include<iostream>

#include<cstring>

#include<algorithm>

using namespace std;

const int L=;

int sub(int *a,int *b,int La,int Lb)

{

    if(La<Lb) return -;//如果a小于b，则返回-1

    if(La==Lb)

    {

        for(int i=La-;i>=;i--)

            if(a[i]>b[i]) break;

            else if(a[i]<b[i]) return -;//如果a小于b，则返回-1

    }

    for(int i=;i<La;i++)//高精度减法

    {

        a[i]-=b[i];

        if(a[i]<) a[i]+=,a[i+]--;

    }

    for(int i=La-;i>=;i--)

        if(a[i]) return i+;//返回差的位数

    return ;//返回差的位数

}

string div(string n1,string n2,int nn)//n1,n2是字符串表示的被除数，除数,nn是选择返回商还是余数

{

    string s,v;//s存商,v存余数

     int a[L],b[L],r[L],La=n1.size(),Lb=n2.size(),i,tp=La;//a，b是整形数组表示被除数，除数，tp保存被除数的长度

     fill(a,a+L,);fill(b,b+L,);fill(r,r+L,);//数组元素都置为0

     for(i=La-;i>=;i--) a[La--i]=n1[i]-'';

     for(i=Lb-;i>=;i--) b[Lb--i]=n2[i]-'';

     if(La<Lb || (La==Lb && n1<n2)) {

            //cout<<0<<endl;

     return n1;}//如果a<b,则商为0，余数为被除数

     int t=La-Lb;//除被数和除数的位数之差

     for(int i=La-;i>=;i--)//将除数扩大10^t倍

        if(i>=t) b[i]=b[i-t];

        else b[i]=;

     Lb=La;

     for(int j=;j<=t;j++)

     {

         int temp;

         while((temp=sub(a,b+j,La,Lb-j))>=)//如果被除数比除数大继续减

         {

             La=temp;

             r[t-j]++;

         }

     }

     for(i=;i<L-;i++) r[i+]+=r[i]/,r[i]%=;//统一处理进位

     while(!r[i]) i--;//将整形数组表示的商转化成字符串表示的

     while(i>=) s+=r[i--]+'';

     //cout<<s<<endl;

     i=tp;

     while(!a[i]) i--;//将整形数组表示的余数转化成字符串表示的</span>

     while(i>=) v+=a[i--]+'';

     if(v.empty()) v="";

     //cout<<v<<endl;

     if(nn==) return s;

     if(nn==) return v;

}

int main()

{

    string a,b;

    while(cin>>a>>b) cout<<div(a,b,)<<endl;

    return ;

}

）高精度除单精度

传入参数约定：传入第一参数为string类型，第二个为int型，返回值为string类型

算法思想：模拟手工除法。

算法复杂度：o(n)

#include<iostream>

#include<algorithm>

using namespace std;

string div(string a,int b)//高精度a除以单精度b

{

    string r,ans;

    int d=;

    if(a=="") return a;//特判

    for(int i=;i<a.size();i++)

    {

            r+=(d*+a[i]-'')/b+'';//求出商

            d=(d*+(a[i]-''))%b;//求出余数

    }

    int p=;

    for(int i=;i<r.size();i++)

    if(r[i]!='') {p=i;break;}

    return r.substr(p);

}

int main()

{

    string a;

    int b;

    while(cin>>a>>b)

    {

        cout<<div(a,b)<<endl;

    }

    return ;

}

.高精度取模

）高精度对高精度取模(以在高精度除高精度中实现，此处不再赘述)

）高精度对单精度取模

传入参数约定：传入第一参数为string类型，第二个为int型，返回值为string类型

算法思想：利用(a+b)%c=a%c+b%c。

算法复杂度：o(n)

#include<iostream>

#include<algorithm>

using namespace std;

int mod(string a,int b)//高精度a除以单精度b

{

    int d=;

    for(int i=;i<a.size();i++) d=(d*+(a[i]-''))%b;//求出余数

    return d;

}

int main()

{

    string a;

    int b;

    while(cin>>a>>b)

    {

        cout<<mod(a,b)<<endl;

    }

    return ;

}

.高精度阶乘

传入参数约定：传入参数为int型，返回值为string类型

算法思想：高精度乘单精度的简单运用。

算法复杂度：o(n^)

#include<iostream>

#include<cstring>

#include<algorithm>

using namespace std;

const int L=;

int a[L];

string fac(int n)

{

    string ans;

    if(n==) return "";

    fill(a,a+L,);

    int s=,m=n;

    while(m) a[++s]=m%,m/=;

    for(int i=n-;i>=;i--)

    {

        int w=;

        for(int j=;j<=s;j++) a[j]=a[j]*i+w,w=a[j]/,a[j]=a[j]%;

        while(w) a[++s]=w%,w/=;

    }

    while(!a[s]) s--;

    while(s>=) ans+=a[s--]+'';

    return ans;

}

int main()

{

    int n;

    while(cin>>n) cout<<fac(n)<<endl;

    return ;

}

.高精度幂

传入参数约定：传入第一参数为string类型，第二个为int型，返回值为string类型

算法思想：FFT高精乘+二分求幂。

算法复杂度：o(n*log(n)*log(m))

#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 = ;

double ax[Maxn], ay[Maxn], bx[Maxn], by[Maxn];

char sa[Maxn/],sb[Maxn/];

int sum[Maxn];

int x1[Maxn],x2[Maxn];

int revv(int x, int bits)

{

    int ret = ;

    for (int i = ; i < bits; i++)

    {

        ret <<= ;

        ret |= x & ;

        x >>= ;

    }

    return ret;

}

void fft(double * a, double * b, int n, bool rev)

{

    int bits = ;

    while ( << bits < n) ++bits;

    for (int i = ; i < n; i++)

    {

        int j = revv(i, bits);

        if (i < j)

            swap(a[i], a[j]), swap(b[i], b[j]);

    }

    for (int len = ; len <= n; len <<= )

    {

        int half = len >> ;

        double wmx = cos( * PI / len), wmy = sin( * PI / len);

        if (rev) wmy = -wmy;

        for (int i = ; i < n; i += len)

        {

            double wx = , wy = ;

            for (int j = ; 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 = ; 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=; L(ln)<len; ++ln);

    len=L(++ln);

    for (int i = ; i < len ; ++i)

    {

        if (i >= na) ax[i] = , ay[i] =;

        else ax[i] = a[i], ay[i] = ;

    }

    fft(ax, ay, len, );

    for (int i = ; i < len; ++i)

    {

        if (i >= nb) bx[i] = , by[i] = ;

        else bx[i] = b[i], by[i] = ;

    }

    fft(bx, by, len, );

    for (int i = ; 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, );

    for (int i = ; i < len; ++i)

        ans[i] = (int)(ax[i] + 0.5);

    return len;

}

string mul(string sa,string sb)

{

    int l1,l2,l;

    int i;

    string ans;

    memset(sum, , sizeof(sum));

    l1 = sa.size();

    l2 = sb.size();

    for(i = ; i < l1; i++)

        x1[i] = sa[l1 - i - ]-'';

    for(i = ; i < l2; i++)

        x2[i] = sb[l2-i-]-'';

    l = solve(x1, l1, x2, l2, sum);

    for(i = ; i<l || sum[i] >= ; i++) // 进位

    {

        sum[i + ] += sum[i] / ;

        sum[i] %= ;

    }

    l = i;

    while(sum[l] <=  && l>)    l--; // 检索最高位

    for(i = l; i >= ; i--)    ans+=sum[i] + ''; // 倒序输出

    return ans;

}

string Pow(string a,int n)

{

    if(n==) return a;

    if(n&) return mul(Pow(a,n-),a);

    string ans=Pow(a,n/);

    return mul(ans,ans);

}

int main()

{

    cin.sync_with_stdio(false);

    string a;

    int b;

    while(cin>>a>>b) cout<<Pow(a,b)<<endl;

    return ;

}

.高精度GCD

传入参数约定：传入参数均为string类型，返回值为string类型

算法思想：高精度加减乘除的运用。

算法复杂度：已无法估计。

#include<iostream>

#include<cstring>

#include<algorithm>

using namespace std;

const int L=;

string add(string a,string b)

{

    string ans;

    int na[L]={},nb[L]={};

    int la=a.size(),lb=b.size();

    for(int i=;i<la;i++) na[la--i]=a[i]-'';

    for(int i=;i<lb;i++) nb[lb--i]=b[i]-'';

    int lmax=la>lb?la:lb;

    for(int i=;i<lmax;i++) na[i]+=nb[i],na[i+]+=na[i]/,na[i]%=;

    if(na[lmax]) lmax++;

    for(int i=lmax-;i>=;i--) ans+=na[i]+'';

    return ans;

}

string mul(string a,string b)

{

    string s;

    int na[L],nb[L],nc[L],La=a.size(),Lb=b.size();//na存储被乘数，nb存储乘数，nc存储积

    fill(na,na+L,);fill(nb,nb+L,);fill(nc,nc+L,);//将na,nb,nc都置为0

    for(int i=La-;i>=;i--) na[La-i]=a[i]-'';//将字符串表示的大整形数转成i整形数组表示的大整形数

    for(int i=Lb-;i>=;i--) nb[Lb-i]=b[i]-'';

    for(int i=;i<=La;i++)

        for(int j=;j<=Lb;j++)

        nc[i+j-]+=na[i]*nb[j];//a的第i位乘以b的第j位为积的第i+j-1位（先不考虑进位）

    for(int i=;i<=La+Lb;i++)

        nc[i+]+=nc[i]/,nc[i]%=;//统一处理进位

    if(nc[La+Lb]) s+=nc[La+Lb]+'';//判断第i+j位上的数字是不是0

    for(int i=La+Lb-;i>=;i--)

        s+=nc[i]+'';//将整形数组转成字符串

    return s;

}

int sub(int *a,int *b,int La,int Lb)

{

    if(La<Lb) return -;//如果a小于b，则返回-1

    if(La==Lb)

    {

        for(int i=La-;i>=;i--)

            if(a[i]>b[i]) break;

            else if(a[i]<b[i]) return -;//如果a小于b，则返回-1

    }

    for(int i=;i<La;i++)//高精度减法

    {

        a[i]-=b[i];

        if(a[i]<) a[i]+=,a[i+]--;

    }

    for(int i=La-;i>=;i--)

        if(a[i]) return i+;//返回差的位数

    return ;//返回差的位数

}

string div(string n1,string n2,int nn)//n1,n2是字符串表示的被除数，除数,nn是选择返回商还是余数

{

    string s,v;//s存商,v存余数

     int a[L],b[L],r[L],La=n1.size(),Lb=n2.size(),i,tp=La;//a，b是整形数组表示被除数，除数，tp保存被除数的长度

     fill(a,a+L,);fill(b,b+L,);fill(r,r+L,);//数组元素都置为0

     for(i=La-;i>=;i--) a[La--i]=n1[i]-'';

     for(i=Lb-;i>=;i--) b[Lb--i]=n2[i]-'';

     if(La<Lb || (La==Lb && n1<n2)) {

            //cout<<0<<endl;

     return n1;}//如果a<b,则商为0，余数为被除数

     int t=La-Lb;//除被数和除数的位数之差

     for(int i=La-;i>=;i--)//将除数扩大10^t倍

        if(i>=t) b[i]=b[i-t];

        else b[i]=;

     Lb=La;

     for(int j=;j<=t;j++)

     {

         int temp;

         while((temp=sub(a,b+j,La,Lb-j))>=)//如果被除数比除数大继续减

         {

             La=temp;

             r[t-j]++;

         }

     }

     for(i=;i<L-;i++) r[i+]+=r[i]/,r[i]%=;//统一处理进位

     while(!r[i]) i--;//将整形数组表示的商转化成字符串表示的

     while(i>=) s+=r[i--]+'';

     //cout<<s<<endl;

     i=tp;

     while(!a[i]) i--;//将整形数组表示的余数转化成字符串表示的</span>

     while(i>=) v+=a[i--]+'';

     if(v.empty()) v="";

     //cout<<v<<endl;

     if(nn==) return s;

     if(nn==) return v;

}

bool judge(string s)//判断s是否为全0串

{

    for(int i=;i<s.size();i++)

        if(s[i]!='') return false;

    return true;

}

string gcd(string a,string b)//求最大公约数

{

    string t;

    while(!judge(b))//如果余数不为0，继续除

    {

        t=a;//保存被除数的值

        a=b;//用除数替换被除数

        b=div(t,b,);//用余数替换除数

    }

    return a;

}

int main()

{

    cin.sync_with_stdio(false);

    string a,b;

    while(cin>>a>>b) cout<<gcd(a,b)<<endl;

    return ;

}

.高精度进制转换

传入参数约定：传入第一个参数为string类型，第二第三均为int型，返回值为string类型

算法思想：模拟手工进制转换。

算法复杂度：o(n^)。

#include<iostream>

#include<algorithm>

using namespace std;

//将字符串表示的10进制大整数转换为m进制的大整数

//并返回m进制大整数的字符串

bool judge(string s)//判断串是否为全零串

{

    for(int i=;i<s.size();i++)

        if(s[i]!='') return ;

    return ;

}

string solve(string s,int n,int m)//n进制转m进制只限0-9进制，若涉及带字母的进制，稍作修改即可

{

    string r,ans;

    int d=;

    if(!judge(s)) return "";//特判

    while(judge(s))//被除数不为0则继续

    {

        for(int i=;i<s.size();i++)

        {

            r+=(d*n+s[i]-'')/m+'';//求出商

            d=(d*n+(s[i]-''))%m;//求出余数

        }

       s=r;//把商赋给下一次的被除数

       r="";//把商清空

        ans+=d+'';//加上进制转换后数字

        d=;//清空余数

    }

    reverse(ans.begin(),ans.end());//倒置下

    return ans;

}

int main()

{

    string s;

    while(cin>>s)

    {

        cout<<solve(s,,)<<endl;

    }

    return ;

}

ACM-高精度模板(综合篇)

标签：高精度

高精度&&FFT的更多相关文章

  1. # BZOJ5300 [CQOI2018]九连环 题解 | 高精度 FFT

    今天做了传说中的CQOI六道板子题--有了一种自己很巨的错觉(雾 题面 求n连环的最少步数,n <= 1e5. 题解 首先--我不会玩九连环-- 通过找规律(其实是百度搜索)可知,\(n\)连环 ...

  2. 两个大数相乘 - 高精度FFT

    HDU 1402 A * B Problem Plus Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (J ...

  3. 【BZOJ】1089: [SCOI2003]严格n元树（递推+高精度/fft）

    http://www.lydsy.com/JudgeOnline/problem.php?id=1089 题意:求深度为d的n元树数目.(0<n<=32, 0<=d<=16) ...

  4. BZOJ 2179 FFT快速傅立叶 题解

    bzoj 2179 Description 给出两个n位10进制整数x和y,你需要计算x*y. [题目分析] 高精裸题.练手. [代码] 1.手动高精 #include<cstdio> # ...

  5. NOIp2014 解题报告

    有史以来第一届面向社会征题的NOIp结束了.最开始以为面向社会征题会很难,但是这是我参加的最水的一次NOIp了. 由于停了两月的课,所以现在正在补文化科目就没时间打代码了.所以所有的题目就均不给出代码 ...

  6. 【bzoj3751】[NOIP2014]解方程 数论

    题目描述 已知多项式方程: a0+a1*x+a2*x^2+...+an*x^n=0 求这个方程在[1,m]内的整数解(n和m均为正整数). 输入 第一行包含2个整数n.m,每两个整数之间用一个空格隔开 ...

  7. wikioi 3132 高精度乘法（FFT）

    第一次学FFT，先膜拜一下法法塔大神ORZ 关于FFT的话，有一篇博文特别赞http://z55250825.blog.163.com/blog/static/15023080920143127465 ...

  8. 【BZOJ5300】[CQOI2018]九连环 （高精度，FFT）

    [BZOJ5300][CQOI2018]九连环 (高精度,FFT) 题面 BZOJ 洛谷 题解 去这里看吧,多么好 #include<iostream> #include<cstdi ...

  9. Codeforces 986D Perfect Encoding FFT 分治 高精度

    原文链接https://www.cnblogs.com/zhouzhendong/p/9161557.html 题目传送门 - Codeforces 986D 题意 给定一个数 $n(n\leq 10 ...

随机推荐

  1. Android线程池（转）

    ．前言 转载请注明出处:http://blog.csdn.net/seu_calvin/article/details/52415337 使用线程池可以给我们带来很多好处,首先通过线程池中线程的重用, ...

  2. Java生成-zipf分布的数据集（自定义倾斜度，用作spark data skew测试）

    1.代码 import java.io.Serializable; import java.util.NavigableMap; import java.util.Random; import jav ...

  3. MS SQL生成数据库字典脚本

    开发一个项目时都会有一个蛋疼的问题——写数据库需求文档,然后根据这个文档来建数据库,如果后来需求改了,要改数据库还要改文档,有时忙着忙着就忘改了,导致文档是过期的.那么我们自己写个脚本在数据库运行直接 ...

  4. cookie安全

    www.baidu.com host 文件 定义 a.baidu.com 为127.0.01 本地编写php程序 读取浏览器发送给 a.baidu.com的cookie 会把 .baidu.com域下 ...

  5. MIPS简单入门

    What ‘s the MIPS? 汇编语言 汇编语言是一类语言的总称,因处理器不同,而对应的不同机器的指令集也不同,产生了很多种汇编语言. 目前最流行的是ARM,MIPS,x86.ARM用于大量的移 ...

  6. python 判断路径是否存在

    import os os.path.exists(文件绝对路径)

  7. c语言文件打开模式

    (转载) 在C语言的文件操作语法中,打开文件文件有以下12种模式,如下图: 打开模式  只可以读   只可以写  读写兼备 文本模式 r w a r+ w+ a+ 二进制模式 rb wb ab  rb ...

  8. C语言格式化说明符

    1.1.1 格式化输入输出函数一.printf()函数printf()函数是格式化输出函数, 一般用于向标准输出设备按规定格式输出信息.在编写程序时经常会用到此函数.printf()函数的调用格式为: ...

  9. 随机生成一份试卷，试卷的种类分为单选、多选、判断三种题型。nodejs6.0 mysql

    背景:从数据库中,随机生成一份试卷,试卷的种类分为单选.多选.判断三种题型. 首先我需要生成随机数id(在这之前我需要知道数据库中各个题型的题数,这样我才能设置随机数),并依据生成的随机数id,去查找 ...

  10. Linux安全调优1：CentOS防火墙的设置与优化

    CentOS防火墙的设置与优化 时间:2014-09-11 02:11来源:blog.csdn.net 作者:成长的小虫 的BLOG 举报 点击:4908次 一.设置主机防火墙. 开放: 服务器的:w ...