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

随机推荐

用JS检测页面加载的不同阶段状态
这可以通过用document.onreadystatechange的方法来监听状态改变, 然后用document.readyState == “complete”判断是否加载完成. 可以采用2个div ...
Web服务器安全设置
Web服务器安全方面一直重视程度不够,是各种网站经常被黑的主要原因.下面笔者总结了一下关于怎样保证Web服务器安全的措施,希望能给那些服务器尚存在漏洞的用户提供一些帮助. 本文主要以Windows s ...
洛谷 P1955 程序自动分析
题目描述在实现程序自动分析的过程中,常常需要判定一些约束条件是否能被同时满足. 考虑一个约束满足问题的简化版本:假设x1,x2,x3...代表程序中出现的变量,给定n个形如xi=xj或xi≠xj的变 ...
递归的可视化（Fibonacci）
递归的可视化修改递归函数,使其能够显示打印出每次函数递归调用的形参的值. 每一级调用的输出都带有一级缩进,就是使得程序的输出清晰.有趣并且有含义. 思路以斐波那契数列为例,假设n=5,递归的形参如 ...
欧拉函数 || LightOJ 1370 Bi-shoe and Phi-shoe
给出x,求最小的y使y的欧拉函数大于等于x *解法:i).求出1e6之内的数的欧拉函数,遍历找 ii).求比x大的第一个质数——因为每个质数n的欧拉函数都是n-1 wa一次是因 ...
从零开始--系统深入学习Android
http://www.cnblogs.com/tianjian/category/354587.html
iOS之绘制像素到屏幕
译注:这篇文章虽然比较长,但是里面的内容还是很有价值的. 像素是如何绘制到屏幕上面的?把数据输出到屏幕的方法有很多,通过调用很多不同的framework和不同的函数.这里我们讲一下这个过程背后的东西. ...
Melancholy（磨懒虫主义）
题目大意:给出n个地点和q个询问.其中每个地点有距离和权值,每个询问给出l,r,k,表示在[l,r]区间内不取最小点的情况下任取k个,求所有情况权值之积之和(n,q<=1e5,k<=6). ...
windows环境下Robot Framework的安装步骤
Robot Framework是由python编写的开源的用来做功能性测试的自动化测试框架.本文介绍Robot Framework在windows环境下的安装步骤. 安装python从python官网 ...
18. PROFILING
18. PROFILING PROFILING表提供语句分析信息. 其内容对应于SHOW PROFILE和SHOW PROFILES语句生成的信息(参见"SHOW PROFILE语法&quo ...

大数c++模板 超级好用

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

随机推荐

热门专题

大数c++模板超级好用

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