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

随机推荐

check_http.c:312: error: ‘ssl_version’
安装nagios-plugins-1.4.16,安装的过程中出现了错误,提示如下.check_http.c:312: error: ‘ssl_version’ undeclared (first us ...
CSV解析
NSString *path = [[NSBundle mainBundle] pathForResource: @"type" ofType:@"csv"]; ...
ubuntu系统apache日志文件的位置
Debian,Ubuntu或Linux Mint上的Apache错误日志位置默认的错误日志在基于Debian的Linux上,系统范围的Apache错误日志默认位置是/var/log/apache2 ...
ubuntu4.04服务器添加虚拟主机
buntu 14.04配置虚拟主机虚拟主机常用于在一个单独的IP地址上提供多个域名的网站服务.如果有人想在单个VPS的单个IP地址运行多个网站,这是非常有用的.在这个教程中,让我告诉你如何设置在 ...
Java面试题之HashSet 的实现原理？
HashSet 的实现原理?首先,我们需要知道它是Set的一个实现,所以保证了当中没有重复的元素.一方面Set中最重要的一个操作就是查找.而且通常我们会选择 HashSet来实现,因为它专门对快速查找 ...
Boxes And Balls(三叉哈夫曼编码)
题目原题链接:http://codeforces.com/problemset/problem/884/D 现有一堆小石子,要求按要求的数目分成N堆,分别为a1.a2....an.具体的,每次选一个 ...
网新恩普（W 笔试）
选择题 1.一桶有黄色,绿色,红色三种,闭上眼睛抓取同种颜色的两个.抓取多少个就可以确定你肯定有两个同一颜色的球? 答案: 4次 1.最坏打算抓3次都是不同颜色的黄.绿.红,此时,三种颜色的球各抓了一 ...
Wow64
翻译自Wikipedia: WoW64 运行在微软平台上,WoW64(Windows 32-bit on Windows 64-bit) 是一个Windows的子操作系统, 它能运行32位的应用,在所 ...
MySQL-05 用户管理
学习目标权限表及其用法账户管理权限管理访问控制权限表 MySQL权限表存放在MySQL数据库里,由mysql_install_db脚本初始化.这些MySQL权限表分别为user.db.pro ...
check.pl
比对两个文件并纠错 #!/usr/bin/perl use strict; use warnings; ###############################################m ...

大数c++模板 超级好用

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

随机推荐

热门专题

大数c++模板超级好用

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