大数c++模板超级好用

只用输入用cin 输出 cout 每个数学符号都可以用超级强大

#include <iostream>

#include <queue>

#include <cstdio>

#include <cstring>

#include <cstdlib>

#include <stack>

using namespace std;

#define maxn 120

class DividedByZeroException {};

class BigInteger

{

private:

    vector<char> digits;

    bool sign;          //  true for positive, false for negitive

    void trim();        //  remove zeros in tail, but if the value is 0, keep only one:)

public:

    BigInteger(int);    // construct with a int integer

    BigInteger(string&) ;

    BigInteger();

    BigInteger (const BigInteger&);

    BigInteger operator=(const BigInteger& op2);

    BigInteger      abs() const;

    BigInteger    pow(int a);

    //binary operators

    friend BigInteger operator+=(BigInteger&,const BigInteger&);

    friend BigInteger operator-=(BigInteger&,const BigInteger&);

    friend BigInteger operator*=(BigInteger&,const BigInteger&);

    friend BigInteger operator/=(BigInteger&,const BigInteger&) throw(DividedByZeroException);

    friend BigInteger operator%=(BigInteger&,const BigInteger&) throw(DividedByZeroException);

    friend BigInteger operator+(const BigInteger&,const BigInteger&);

    friend BigInteger operator-(const BigInteger&,const BigInteger&);

    friend BigInteger operator*(const BigInteger&,const BigInteger&);

    friend BigInteger operator/(const BigInteger&,const BigInteger&) throw(DividedByZeroException);

    friend BigInteger operator%(const BigInteger&,const BigInteger&) throw(DividedByZeroException);

    //uniary operators

    friend BigInteger operator-(const BigInteger&);   //negative

    friend BigInteger operator++(BigInteger&);        //++v

    friend BigInteger operator++(BigInteger&,int);    //v++

    friend BigInteger operator--(BigInteger&);        //--v

    friend BigInteger operator--(BigInteger&,int);    //v--

    friend bool operator>(const BigInteger&,const BigInteger&);

    friend bool operator<(const BigInteger&,const BigInteger&);

    friend bool operator==(const BigInteger&,const BigInteger&);

    friend bool operator!=(const BigInteger&,const BigInteger&);

    friend bool operator>=(const BigInteger&,const BigInteger&);

    friend bool operator<=(const BigInteger&,const BigInteger&);

    friend ostream& operator<<(ostream&,const BigInteger&);    //print the BigInteger

    friend istream& operator>>(istream&, BigInteger&);         // input the BigInteger

public:

    static const BigInteger ZERO;

    static const BigInteger ONE;

    static const BigInteger TEN;

};

// BigInteger.cpp

const BigInteger BigInteger::ZERO=BigInteger();

const BigInteger BigInteger::ONE =BigInteger();

const BigInteger BigInteger::TEN =BigInteger();

BigInteger::BigInteger()

{

    sign=true;

}

BigInteger::BigInteger(int val) // construct with a int integer

{

    if (val >= )

        sign = true;

    else

    {

        sign = false;

        val *= (-);

    }

    do

    {

        digits.push_back( (char)(val%) );

        val /= ;

    }

    while ( val !=  );

}

BigInteger::BigInteger(string& def)

{

    sign=true;

    for ( string::reverse_iterator iter = def.rbegin() ; iter < def.rend();  iter++)

    {

        char ch = (*iter);

        if (iter == def.rend()-)

        {

            if ( ch == '+' )

                break;

            if(ch == '-' )

            {

                sign = false;

                break;

            }

        }

        digits.push_back( (char)((*iter) - '' ) );

    }

    trim();

}

void BigInteger::trim()

{

    vector<char>::reverse_iterator iter = digits.rbegin();

    while(!digits.empty() && (*iter) == )

    {

        digits.pop_back();

        iter=digits.rbegin();

    }

    if( digits.size()== )

    {

        sign = true;

        digits.push_back();

    }

}

BigInteger::BigInteger(const BigInteger& op2)

{

    sign = op2.sign;

    digits=op2.digits;

}

BigInteger BigInteger::operator=(const BigInteger& op2)

{

    digits = op2.digits;

    sign = op2.sign;

    return (*this);

}

BigInteger BigInteger::abs() const

{

    if(sign)  return *this;

    else      return -(*this);

}

BigInteger BigInteger::pow(int a)

{

    BigInteger res();

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

        res*=(*this);

    return res;

}

//binary operators

BigInteger operator+=(BigInteger& op1,const BigInteger& op2)

{

    if( op1.sign == op2.sign )

    {

        //只处理相同的符号的情况，异号的情况给-处理

        vector<char>::iterator iter1;

        vector<char>::const_iterator iter2;

        iter1 = op1.digits.begin();

        iter2 = op2.digits.begin();

        char to_add = ;        //进位

        while ( iter1 != op1.digits.end() && iter2 != op2.digits.end())

        {

            (*iter1) = (*iter1) + (*iter2) + to_add;

            to_add = ((*iter1) > );    // 大于9进一位

            (*iter1) = (*iter1) % ;

            iter1++;

            iter2++;

        }

        while ( iter1 != op1.digits.end() )    //

        {

            (*iter1) = (*iter1) + to_add;

            to_add = ( (*iter1) >  );

            (*iter1) %= ;

            iter1++;

        }

        while ( iter2 != op2.digits.end() )

        {

            char val = (*iter2) + to_add;

            to_add = (val > ) ;

            val %= ;

            op1.digits.push_back(val);

            iter2++;

        }

        if( to_add !=  )

            op1.digits.push_back(to_add);

        return op1;

    }

    else

    {

        if (op1.sign)

            return op1 -= (-op2);

        else

            return op1= op2 - (-op1);

    }

}

BigInteger operator-=(BigInteger& op1,const BigInteger& op2)

{

    if( op1.sign == op2.sign )

    {

        //只处理相同的符号的情况，异号的情况给+处理

        if(op1.sign)

        {

            if(op1 < op2)  // 2 - 3

                return  op1=-(op2 - op1);

        }

        else

        {

            if(-op1 > -op2)  // (-3)-(-2) = -(3 - 2)

                return op1=-((-op1)-(-op2));

            else             // (-2)-(-3) = 3 - 2

                return op1= (-op2) - (-op1);

        }

        vector<char>::iterator iter1;

        vector<char>::const_iterator iter2;

        iter1 = op1.digits.begin();

        iter2 = op2.digits.begin();

        char to_substract = ;  //借位

        while ( iter1 != op1.digits.end() && iter2 != op2.digits.end())

        {

            (*iter1) = (*iter1) - (*iter2) - to_substract;

            to_substract = ;

            if( (*iter1) <  )

            {

                to_substract=;

                (*iter1) += ;

            }

            iter1++;

            iter2++;

        }

        while ( iter1 != op1.digits.end() )

        {

            (*iter1) = (*iter1) - to_substract;

            to_substract = ;

            if( (*iter1) <  )

            {

                to_substract=;

                (*iter1) += ;

            }

            else break;

            iter1++;

        }

        op1.trim();

        return op1;

    }

    else

    {

        if (op1 > BigInteger::ZERO)

            return op1 += (-op2);

        else

            return op1 = -(op2 + (-op1));

    }

}

BigInteger operator*=(BigInteger& op1,const BigInteger& op2)

{

    BigInteger result();

    if (op1 == BigInteger::ZERO || op2==BigInteger::ZERO)

        result = BigInteger::ZERO;

    else

    {

        vector<char>::const_iterator iter2 = op2.digits.begin();

        while( iter2 != op2.digits.end() )

        {

            if(*iter2 != )

            {

                deque<char> temp(op1.digits.begin() , op1.digits.end());

                char to_add = ;

                deque<char>::iterator iter1 = temp.begin();

                while( iter1 != temp.end() )

                {

                    (*iter1) *= (*iter2);

                    (*iter1) += to_add;

                    to_add = (*iter1) / ;

                    (*iter1) %= ;

                    iter1++;

                }

                if( to_add != )

                    temp.push_back( to_add );

                int num_of_zeros = iter2 - op2.digits.begin();

                while(  num_of_zeros--)

                    temp.push_front();

                BigInteger temp2;

                temp2.digits.insert( temp2.digits.end() , temp.begin() , temp.end() );

                temp2.trim();

                result = result + temp2;

            }

            iter2++;

        }

        result.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );

    }

    op1 = result;

    return op1;

}

BigInteger operator/=(BigInteger& op1 , const BigInteger& op2 ) throw(DividedByZeroException)

{

    if( op2 == BigInteger::ZERO )

        throw DividedByZeroException();

    BigInteger t1 = op1.abs(), t2 = op2.abs();

    if ( t1 < t2 )

    {

        op1 = BigInteger::ZERO;

        return op1;

    }

    //现在 t1 > t2 > 0

    //只需将 t1/t2的结果交给result就可以了

    deque<char> temp;

    vector<char>::reverse_iterator iter = t1.digits.rbegin();

    BigInteger temp2();

    while( iter != t1.digits.rend() )

    {

        temp2 = temp2 * BigInteger::TEN + BigInteger( (int)(*iter) );

        char s = ;

        while( temp2 >= t2 )

        {

            temp2 = temp2 - t2;

            s = s + ;

        }

        temp.push_front( s );

        iter++;

    }

    op1.digits.clear();

    op1.digits.insert( op1.digits.end() , temp.begin() , temp.end() );

    op1.trim();

    op1.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );

    return op1;

}

BigInteger operator%=(BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException)

{

    return op1 -= ((op1 / op2)*op2);

}

BigInteger operator+(const BigInteger& op1,const BigInteger& op2)

{

    BigInteger temp(op1);

    temp += op2;

    return temp;

}

BigInteger operator-(const BigInteger& op1,const BigInteger& op2)

{

    BigInteger temp(op1);

    temp -= op2;

    return temp;

}

BigInteger operator*(const BigInteger& op1,const BigInteger& op2)

{

    BigInteger temp(op1);

    temp *= op2;

    return temp;

}

BigInteger operator/(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException)

{

    BigInteger temp(op1);

    temp /= op2;

    return temp;

}

BigInteger operator%(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException)

{

    BigInteger temp(op1);

    temp %= op2;

    return temp;

}

//uniary operators

BigInteger operator-(const BigInteger& op)    //negative

{

    BigInteger temp = BigInteger(op);

    temp.sign = !temp.sign;

    return temp;

}

BigInteger operator++(BigInteger& op)     //++v

{

    op += BigInteger::ONE;

    return op;

}

BigInteger operator++(BigInteger& op,int x)   //v++

{

    BigInteger temp(op);

    ++op;

    return temp;

}

BigInteger operator--(BigInteger& op)     //--v

{

    op -=  BigInteger::ONE;

    return op;

}

BigInteger operator--(BigInteger& op,int x)   //v--

{

    BigInteger temp(op);

    --op;

    return temp;

}

bool operator<(const BigInteger& op1,const BigInteger& op2)

{

    if( op1.sign != op2.sign )

        return !op1.sign;

    else

    {

        if(op1.digits.size() != op2.digits.size())

            return (op1.sign && op1.digits.size()<op2.digits.size())

                   || (!op1.sign && op1.digits.size()>op2.digits.size());

        vector<char>::const_reverse_iterator iter1,iter2;

        iter1 = op1.digits.rbegin();

        iter2 = op2.digits.rbegin();

        while( iter1 != op1.digits.rend() )

        {

            if(  op1.sign &&  *iter1 < *iter2 ) return true;

            if(  op1.sign &&  *iter1 > *iter2 ) return false;

            if( !op1.sign &&  *iter1 > *iter2 ) return true;

            if( !op1.sign &&  *iter1 < *iter2 ) return false;

            iter1++;

            iter2++;

        }

        return false;

    }

}

bool operator==(const BigInteger& op1,const BigInteger& op2)

{

    if( op1.sign != op2.sign  || op1.digits.size() != op2.digits.size() )

        return false;

    vector<char>::const_iterator iter1,iter2;

    iter1 = op1.digits.begin();

    iter2 = op2.digits.begin();

    while( iter1!= op1.digits.end() )

    {

        if( *iter1 != *iter2 )  return false;

        iter1++;

        iter2++;

    }

    return true;

}

bool operator!=(const BigInteger& op1,const BigInteger& op2)

{

    return !(op1==op2);

}

bool operator>=(const BigInteger& op1,const BigInteger& op2)

{

    return (op1>op2) || (op1==op2);

}

bool operator<=(const BigInteger& op1,const BigInteger& op2)

{

    return (op1<op2) || (op1==op2);

}

bool operator>(const BigInteger& op1,const BigInteger& op2)

{

    return !(op1<=op2);

}

ostream& operator<<(ostream& stream,const BigInteger& val)     //print the BigInteger

{

    if (!val.sign)

        stream << "-";

    for ( vector<char>::const_reverse_iterator iter = val.digits.rbegin(); iter != val.digits.rend() ; iter++)

        stream << (char)((*iter) + '');

    return stream;

}

istream& operator>>(istream& stream, BigInteger& val)

{

    //Input the BigInteger

    string str;

    stream >> str;

    val=BigInteger(str);

    return stream;

}

int T, n;

BigInteger a[];

bool solve()

{

    int cnt = ;

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

    {

        if(a[i] == )

            cnt ++;

    }

    if(cnt && cnt!=n)

        return false;

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

    {

        if( a[i-]*a[i+] != a[i]*a[i])

            return false;

    }

    return true;

}

int main()

{

    int T;

    BigInteger q, p, ans;

    scanf("%d", &T);

    while(T--)

    {

        cin>>q>>p;

        q = q-;

        ans = (q+)*q/%p;

        cout<<ans<<endl;

    }

    return ;

}

大数c++模板超级好用的更多相关文章

hdu_1041(Computer Transformation) 大数加法模板+找规律
Computer Transformation Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/ ...
JAVA 大数开方模板
JAVA 大数开方模板 import java.math.BigInteger; import java.math.*; import java.math.BigInteger; import jav ...
C++大数类模板
友情提示:使用该模板的注意了,在大数减法里有一个小错误,导致减法可能会出错 // 原来的写法,将t1.len错写成了len ] == && t1.len > ) { t1.len ...
Pollard_Rho大数分解模板题 pku-2191
题意:给你一个数n, 定义m=2k-1, {k|1<=k<=n},并且 k为素数; 当m为合数时,求分解为质因数,输出格式如下:47 * 178481 = 8388607 = ( ...
java的大数运算模板
import java.math.BigInteger; import java.util.Scanner; public class Main { public static void main(S ...
icpc 江苏 D Persona5 组合数学大数阶乘（分段阶乘）大数阶乘模板
Persona5 is a famous video game. In the game, you are going to build relationship with your friends. ...
C++大数运算模板
#include<iostream> #include<cstring> #include<cstdio> #include<iomanip> #inc ...
PAT A1024题解——高精度大数相加模板
PAT:A1024 Palindromic Number A number that will be the same when it is written forwards or backwards ...
nyoj 28-大数阶乘 (大数模板)
28-大数阶乘内存限制:64MB 时间限制:3000ms Special Judge: No accepted:19 submit:39 题目描述: 我们都知道如何计算一个数的阶乘,可是,如果这个数 ...

随机推荐

登录脚本重构Element
登录脚本重构Element package com.gubai.selenium; import org.openqa.selenium.By; import org.openqa.selenium. ...
COGS 2685. 迷妹
★ 输入文件:fans.in 输出文件:fans.out 简单对比时间限制:1 s 内存限制:256 MB [题目描述] 小钟.小皓和小曦都是著名偶像派OI选手,他们都有很多迷妹. 现 ...
洛谷 P1454 圣诞夜的极光 == codevs 1293 送给圣诞夜的极光
题目背景圣诞夜系列~~ 题目描述圣诞老人回到了北极圣诞区,已经快到12点了.也就是说极光表演要开始了.这里的极光不是极地特有的自然极光景象.而是圣诞老人主持的人造极光. 轰隆隆……烟花响起(来自中 ...
flask_第一个程序
安装flask sudo pip3 install flask falsk最小应用 from flask import Flask app = Flask(__name__) @app.route(' ...
C++中vector用法
在c++中,vector是一个十分有用的容器,下面对这个容器做一下总结. 1 基本操作 (1)头文件#include<vector>. (2)创建vector对象,vector<in ...
json-server && axios
json-server && axios vue2.0项目实战(3)使用axios发送请求 https://www.cnblogs.com/zhouyangla/p/6753673.h ...
CAD交互绘制带周长面积的矩形框（网页版）
主要用到函数说明: _DMxDrawX::DrawLine 绘制一个直线.详细说明如下: 参数说明 DOUBLE dX1 直线的开始点x坐标 DOUBLE dY1 直线的开始点y坐标 DOUBLE ...
python调用aapt工具直接获取包名和tagertSdkversion
背景: 每次海外游戏上架都需要符合google的上架规则,其中适配方面tagetSdkversion有硬性要求,比如需要适配安卓q就需要tagetSdkversion达到28,水平太渣的我每次调用aa ...
encodeURI()与decodeURI()等转码方法
只针对文本编码 encodeURI() 只针对文本解码 decodeURI()针对文本和特殊字符的编码 encodeURIComponent()针对文本和特殊字符的解码 decodeURIComp ...
【亲测可行】Dev c++调试、运行报错解决方法总结
一.编译后 0错误 0警告,但是开始出现‘‘停止运行’’或者进行输入时出现‘‘停止运行’’ 可能的原因: 结构体指针为空,但调用了其成员. 有些scanf语句中忘记添加取址符. 无法跳出递归. 二. ...

大数c++模板 超级好用

大数c++模板 超级好用的更多相关文章

随机推荐

热门专题

大数c++模板超级好用

大数c++模板超级好用的更多相关文章