高精度

高精度 模板库

其实高精度就按你平时手算的的方法写出来就好了
这份代码用 $long \ long$ 压 $8$ 位
高精乘可以用FFT优化（这里没有）
高精除需要使用 $2$ 的幂次来试商，这样会快很多

其实这东西要的就是一个稳，一般用到高精的东西最后不是别的地方错了，而是高精错了。

#include<vector>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
namespace Super_Calc{
    typedef long long LL;
    const int WIDTH = 10000+9;
    const int MOD = 100000000;
    char BUF[WIDTH];
    struct Num{
        vector<LL> vec;
    };
    struct PAIR{
        Num first;
        bool second;
    };
    Num Input(){
        Num re;
        scanf("%s",BUF);
        int len=strlen(BUF);
        for(int i=len-1;i>=7;i-=8){
            LL tmp=0;
            for(int j=7;j>=0;j--)
                tmp=tmp*10+BUF[i-j]-'0';
            re.vec.push_back(tmp);
        }
        len=len%8;
        if(len==0)return re;
        LL tmp=0;
        for(int i=0;i<=len-1;i++)
            tmp=tmp*10+BUF[i]-'0';
        re.vec.push_back(tmp);
        return re;
    }
    void Print(const Num &A,char s=0,bool sign=1){
        if(!sign)putchar('-');
        sprintf(BUF,"%lld",A.vec.back());
        printf("%s",BUF);
        for(int i=A.vec.size()-2;i>=0;i--){
            sprintf(BUF,"%08lld",A.vec[i]);
            printf("%s",BUF);
        }
        if(s)putchar(s);
    }
    Num Change(LL val){
        Num re;
        re.vec.push_back(val);
        return re;
    }
    Num operator << (const Num &A,int k){
        Num re;
        re.vec.resize(A.vec.size()+k);
        for(int i=k,j=0;j<A.vec.size();i++,j++){
            re.vec[i]=A.vec[j];
        }
        return re;
    }
    bool operator < (const Num &A,const Num &B){
        if(A.vec.size()!=B.vec.size())
            return A.vec.size()<B.vec.size();
        int len=A.vec.size();
        for(int i=len-1;i>=0;i--){
            if(A.vec[i]<B.vec[i])return true;
            if(A.vec[i]>B.vec[i])return false;
        }
        return false;
    }
    bool operator <= (const Num &A,const Num &B){
        if(A.vec.size()!=B.vec.size())
            return A.vec.size()<B.vec.size();
        int len=A.vec.size();
        for(int i=len-1;i>=0;i--){
            if(A.vec[i]<B.vec[i])return true;
            if(A.vec[i]>B.vec[i])return false;
        }
        return true;
    }
    bool operator > (const Num &A,const Num &B){
        if(A.vec.size()!=B.vec.size())
            return A.vec.size()>B.vec.size();
        int len=A.vec.size();
        for(int i=len-1;i>=0;i--){
            if(A.vec[i]>B.vec[i])return true;
            if(A.vec[i]<B.vec[i])return false;
        }
        return false;
    }
    bool operator >= (const Num &A,const Num &B){
        if(A.vec.size()!=B.vec.size())
            return A.vec.size()>B.vec.size();
        int len=A.vec.size();
        for(int i=len-1;i>=0;i--){
            if(A.vec[i]>B.vec[i])return true;
            if(A.vec[i]<B.vec[i])return false;
        }
        return true;
    }
    bool operator == (const Num &A,const Num &B){
        if(A.vec.size()!=B.vec.size())
            return false;
        int len=A.vec.size();
        for(int i=0;i<len;i++)
            if(A.vec[i]!=B.vec[i])return false;
        return true;
    }
    Num operator + (const Num &A,const Num &B){
        Num re;
        re.vec.resize(max(A.vec.size(),B.vec.size())+1);
        for(int i=0;i<A.vec.size();i++){
            re.vec[i]+=A.vec[i];
        }
        for(int i=0;i<B.vec.size();i++){
            re.vec[i]+=B.vec[i];
        }
        for(int i=0;i<re.vec.size()-1;i++){
            re.vec[i+1]+=re.vec[i]/MOD;
            re.vec[i]%=MOD;
        }
        while(!re.vec.back() && re.vec.size()>1) re.vec.pop_back();
        return re;
    }
    PAIR operator - (const Num &A,const Num &B){
        Num X,Y;
        bool pd;
        if(A==B){X.vec.push_back(0);return (PAIR){X,1};}
        if(A>B){X=A;Y=B;pd=1;}
        else{X=B;Y=A;pd=0;}
        for(int i=0;i<Y.vec.size();i++){
            X.vec[i]-=Y.vec[i];
        }
        for(int i=0;i<X.vec.size()-1;i++){
            if(X.vec[i]<0){
                X.vec[i]+=MOD;
                X.vec[i+1]--;
            }
        }
        while(!X.vec.back() && X.vec.size()>1)X.vec.pop_back();
        return (PAIR){X,pd};
    }
    Num operator * (const Num &A,const Num &B){
        Num re;
        re.vec.resize(A.vec.size()+B.vec.size()+1);
        for(int i=0,lim=A.vec.size();i<lim;i++){
            for(int j=0,lim=B.vec.size();j<lim;j++){
                re.vec[i+j]+=A.vec[i]*B.vec[j];
            }
        }
        for(int i=0,lim=re.vec.size();i<lim;i++){
            re.vec[i+1]+=re.vec[i]/MOD;
            re.vec[i]%=MOD;
        }
        while(!re.vec.back() && re.vec.size()>1) re.vec.pop_back();
        return re;
    }
    Num DivMod(const Num &A,const Num &B,Num &R){
        R=A;
        Num re;
        re.vec.resize(A.vec.size()-B.vec.size()+1);
        for(int i=re.vec.size()-1;i>=0;i--){
            Num val10=B<<i;
            for(int j=26;j>=0;j--){
                LL tmp=1<<j;
                Num val2=val10*Change(tmp);
                if(R>=val2){
                    R=(R-val2).first;
                    re.vec[i]+=tmp;
                }
            }
        }
        while(!re.vec.back() && re.vec.size()>1) re.vec.pop_back();
        return re;
    }
    Num operator / (const Num &A,const Num &B){
        Num re;
        if(A==B){re.vec.push_back(1);return re;}
        if(A<B){re.vec.push_back(0);return re;}
        Num X;
        re=DivMod(A,B,X);
        return re;
    }
    Num operator % (const Num &A,const Num &B){
        Num re;
        if(A==B){re.vec.push_back(0);return re;}
        if(A<B){return A;}
        Num X;
        DivMod(A,B,X);
        return X;
    }
}
using namespace Super_Calc;
int main(){
    Num A=Input();
    Num B=Input();
    Print(A+B,'\n');
    PAIR C=A-B;
    Print(C.first,'\n',C.second);
    Print(A*B,'\n');
    Print(A/B,'\n');
    Print(A%B,'\n');
    return 0;
}