大数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 题目描述: 我们都知道如何计算一个数的阶乘,可是,如果这个数 ...

随机推荐

系统设计摘录CAP
系统架构设计理论与原则这里主要介绍几种常见的架构设计理论和原则,常见于大中型互联系统架构设计. (一).CAP理论 1.什么是CAP 所谓CAP,即一致性(Consistency).可用性(Avai ...
VBA 连接sql server的用法
cnnstr = "Provider=sqloledb;Data Source=192.211.21.8;Initial Catalog=pub;UID=账号;PWD=密码" VB ...
洛谷 P2153 [SDOI2009]晨跑
题目描述 Elaxia最近迷恋上了空手道,他为自己设定了一套健身计划,比如俯卧撑.仰卧起坐等等,不过到目前为止,他坚持下来的只有晨跑. 现在给出一张学校附近的地图,这张地图中包含N个十字路口和M条街 ...
基于SAE的Python+Django部署
本文主要参考:http://www.cnblogs.com/qtsharp/archive/2012/01/12/2320774.html,另外包括自己的实际操作. 一.申请SAE帐号以及创建应用ya ...
Python3简明教程（四）—— 流程控制之分支
我们通过 if-else 语句来做决定,来改变程序运行的流程. if语句语法如下: if expression: do this 如果表达式 expression 的值为真(不为零的任何值都为真), ...
旅行商问题——状态压缩DP
问题简介有n个城市,每个城市间均有道路,一个推销员要从某个城市出发,到其余的n-1个城市一次且仅且一次,然后回到再回到出发点.问销售员应如何经过这些城市是他所走的路线最短? 用图论的语言描述就是:给 ...
run_debug和run_demo的区别
run_demo:给一张图,直接生成测试出来的框,输入不用给gt框 run_debug:生成ap值,生成的图片既有gt框也有测试得到的结果框 run_demo的源码demo_test放在example ...
使用snapshot继续训练网络
注意:snapshots和weights不能同时使用用预训练模型进行finetune是以下命令: ./build/tools/caffe train --solver=examples/XXX/le ...
SQL比较两表字段和字段类型
一.问题业务需要把TB_Delete_KYSubProject表数据恢复到TB_KYSubProject,但提示错误,错误原因是两表字段类型存在不一致 insert into [TB_KYSubPr ...
C指针类型转换问题
先看下面的代码: #include<stdio.h> int main () { int a; char *x; x = (char *) &a; a = 512; x[0] = ...

大数c++模板 超级好用

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

随机推荐

热门专题

大数c++模板超级好用

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