P1932 A+B A-B A*B A/B A%B Problem

题目

高精度加减乘除模。

分析

高精度模板，这里还是压位高精。

代码

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#ifndef _INTEGER_HPP_
#define _INTEGER_HPP_

namespace PsephurusGladius{
    namespace integer{
        const int Max_Integer_Length=1e4;
        char char_array_temp[Max_Integer_Length];
        class Integer{
            private:
                int digit[Max_Integer_Length],count;
                short signum;
            public:
                Integer(void);
                Integer(const Integer &target);
                Integer(const long long &target);
                Integer(const char *target);
                operator char*(void);
                void zero(void);
                friend std::istream& operator >>(std::istream &Cin,Integer &target);
                friend std::ostream& operator <<(std::ostream &Cout,const Integer &target);
                Integer absolute_value(void)const;
                Integer opposite_number(void)const;
                Integer operator -(void)const;
                friend bool operator <(const Integer &target1,const Integer &target2);
                friend bool operator >(const Integer &target1,const Integer &target2);
                friend bool operator <=(const Integer &target1,const Integer &target2);
                friend bool operator >=(const Integer &target1,const Integer &target2);
                friend bool operator ==(const Integer &target1,const Integer &target2);
                friend bool operator !=(const Integer &target1,const Integer &target2);
                friend Integer operator +(const Integer &target1,const Integer &target2);
                friend Integer operator -(const Integer &target1,const Integer &target2);
                friend Integer operator *(const Integer &target1,const Integer &target2);
                friend Integer operator /(const Integer &target1,const Integer &target2);
                friend Integer operator %(const Integer &target1,const Integer &target2);
                Integer& operator ++(void);
                Integer operator ++(int);
                Integer& operator --(void);
                Integer operator --(int);
                Integer operator +=(const Integer &target);
                Integer operator -=(const Integer &target);
                Integer operator *=(const Integer &target);
                Integer operator /=(const Integer &target);
                Integer operator %=(const Integer &target);
        };
        inline Integer::Integer(void):count(0),signum(0){
            memset(digit,0,sizeof(digit));
        }
        inline Integer::Integer(const Integer &target):count(target.count),signum(target.signum){
            memcpy(digit,target.digit,sizeof(digit));
        }
        inline Integer::Integer(const long long &target){
            memset(digit,0,sizeof(digit));
            signum=target<0?-1:(target>0?1:0);
            count=-1;
            long long temp=target;
            do{
                digit[++count]=temp%10000;
                temp/=10000;
            }
            while(temp);
        }
        inline Integer::Integer(const char *target){
            memset(digit,0,sizeof(digit));
            int start=0,len=strlen(target);
            if(target[0]=='-'&&(target[1]!='0'||len!=2)){
                signum=-1;
                ++start;
            }
            else if(target[0]!='0'||len!=1)signum=1;
            else signum=0;
            count=(len-start-1)/4;
            for(int i=start,sum=0;i<len;++i)
            {
                sum=sum*10+target[i]-'0';
                if(!((len-i-1)%4))
                {
                    digit[count-(i-start)/4]=sum;
                    sum=0;
                }
            }
            while(count>0&&!digit[count])
                --count;
        }
        inline Integer::operator char*(void)
        {
            memset(char_array_temp,0,sizeof(char_array_temp));
            for(int i=count,len=0;i>-1;--i)
            {
                if(i==count)
                {
                    len+=sprintf(char_array_temp+len,"%d",digit[i]);
                    continue;
                }
                len+=sprintf(char_array_temp+len,"%04d",digit[i]);
            }
            return char_array_temp;
        }
        inline void Integer::zero(void)
        {
            memset(digit,0,sizeof(digit));
            count=signum=0;
        }
        inline std::istream& operator >>(std::istream &Cin,Integer &target)
        {
            scanf("%s",char_array_temp);
            target=Integer(char_array_temp);
            return Cin;
        }
        inline std::ostream& operator <<(std::ostream &Cout,const Integer &target)
        {
            if(target.signum==-1)
                printf("-");
            printf("%d",target.digit[target.count]);
            for(int i=target.count-1;i>-1;--i)
                printf("%04d",target.digit[i]);
            return Cout;
        }
        inline Integer Integer::absolute_value(void)const
        {
            if(!count&&!signum)
                return *this;
            else
            {
                Integer result=*this;
                result.signum=1;
                return result;
            }
        }
        inline Integer Integer::opposite_number(void)const
        {
            Integer result=*this;
            result.signum*=-1;
            return result;
        }
        Integer Integer::operator -(void)const
        {
            return opposite_number();
        }
        inline bool operator <(const Integer &target1,const Integer &target2)
        {
             if(target1.signum!=target2.signum)
                 return target1.signum<target2.signum;
             if(target1.signum==-1)
                 return target2.absolute_value()<target1.absolute_value();
            if(target1.count!=target2.count)
                 return target1.count<target2.count;
             for(int i=target1.count;i>-1;--i)
                 if(target1.digit[i]!=target2.digit[i])
                     return target1.digit[i]<target2.digit[i];
             return false;
        }
        inline bool operator >(const Integer &target1,const Integer &target2)
        {
            return !(target1<target2)&&!(target1==target2);
        }
        inline bool operator ==(const Integer &target1,const Integer &target2)
        {
            if(target1.signum!=target2.signum||target1.count!=target2.count)
                 return false;
             for(int i=target1.count;i>-1;--i)
                 if(target1.digit[i]!=target2.digit[i])
                     return false;
             return true;
        }
        inline bool operator <=(const Integer &target1,const Integer &target2)
        {
            return target1<target2||target1==target2;
        }
        inline bool operator >=(const Integer &target1,const Integer &target2)
        {
            return !(target1<target2);
        }
        inline bool operator !=(const Integer &target1,const Integer &target2)
        {
            return !(target1==target2);
        }
        inline Integer operator +(const Integer &target1,const Integer &target2)
        {
            if(target1.signum!=target2.signum)
                if(!target1.signum||!target2.signum)
                    return target1.signum?target1:target2;
                else return target1.signum<target2.signum?target2-target1.absolute_value():target1-target2.absolute_value();
            Integer result;
            result.count=target1.count<target2.count?target2.count:target1.count;
            result.signum=target1.signum;
            for(int i=0;i<=result.count;++i)
            {
                result.digit[i]+=target1.digit[i]+target2.digit[i];
                result.digit[i+1]=result.digit[i]/10000;
                result.digit[i]%=10000;
            }
            if(result.digit[result.count+1])
                ++result.count;
            return result;
        }
        inline Integer operator -(const Integer &target1,const Integer &target2)
        {
            if(target1.signum!=target2.signum)
                if(!target1.signum||!target2.signum)
                    return target1.signum?target1:target2.opposite_number();
                else return target1.signum<target2.signum?(target1.absolute_value()+target2).opposite_number():target1+target2.absolute_value();
            if(target1<target2)
                return (target2-target1).opposite_number();
            Integer result;
            if(target1==target2)
                return result;
            result.count=target1.count;
            result.signum=1;
            for(int i=0;i<=result.count;++i)
            {
                result.digit[i]+=target1.digit[i]-target2.digit[i];
                if(result.digit[i]<0)
                {
                    --result.digit[i+1];
                    result.digit[i]+=10000;
                }
            }
            while(result.count>0&&!result.digit[result.count])
                --result.count;
            return result;
        }
        inline Integer operator *(const Integer &target1,const Integer &target2)
        {
            Integer result;
            if(!target1.signum&&!target2.signum)
                return result;
            result.signum=target1.signum*target2.signum;
            result.count=target1.count+target2.count+1;
            for(int i=0;i<=target1.count;++i)
                for(int j=0;j<=target2.count;++j)
                {
                    result.digit[i+j]+=target1.digit[i]*target2.digit[j];
                    result.digit[i+j+1]+=result.digit[i+j]/10000;
                    result.digit[i+j]%=10000;
                }
            while(result.count>0&&!result.digit[result.count])
                --result.count;
            return result;
        }
        inline Integer operator /(const Integer &target1,const Integer &target2)
        {
            Integer result,temp,now;
            if(!target1.signum||target1.absolute_value()<target2.absolute_value())
                return result;
            if(!target2.signum)
                throw std::logic_error("divide by zero!");
            result.signum=target1.signum*target2.signum;
            result.count=target1.count;
            now.signum=1;
            for(int i=result.count;i>-1;--i)
            {
                for(int j=now.count;j>-1;--j)
                    now.digit[j+1]=now.digit[j];
                now.digit[0]=target1.digit[i];
                if(now.digit[now.count+1])
                    ++now.count;
                now.signum=1;
                if(now<target2)
                    continue;
                int left=0,right=9999;
                while(left<right)
                {
                    int mid=(left+right)/2;
                    if(target2*Integer(mid)<=now)
                        left=mid+1;
                    else
                        right=mid;
                }
                result.digit[i]=left-1;
                now-=Integer(left-1)*target2;
            }
            while(result.count>0&&!result.digit[result.count])
                --result.count;
            return result;
        }
        inline Integer operator %(const Integer &target1,const Integer &target2)
        {
            return target1-target1/target2*target2;
        }
        inline Integer& Integer::operator ++(void)
        {
            return *this=*this+Integer(1ll);
        }
        inline Integer Integer::operator ++(int)
        {
            Integer result=*this;
            ++*this;
            return result;
        }
        inline Integer& Integer::operator --(void)
        {
            return *this=*this-Integer(1ll);
        }
        inline Integer Integer::operator --(int)
        {
            Integer result=*this;
            --*this;
            return result;
        }
        inline Integer Integer::operator +=(const Integer &target)
        {
            return *this=*this+target;
        }
        inline Integer Integer::operator -=(const Integer &target)
        {
            return *this=*this-target;
        }
        inline Integer Integer::operator *=(const Integer &target)
        {
            return *this=*this*target;
        }
        inline Integer Integer::operator /=(const Integer &target)
        {
            return *this=*this/target;
        }
        inline Integer Integer::operator %=(const Integer &target)
        {
            return *this=*this%target;
        }
    }
}

#endif
using namespace PsephurusGladius;
using namespace integer;
Integer a,b;
signed main(){
	cin>>a>>b;
	cout<<a+b<<endl<<a-b<<endl<<a*b<<endl<<a/b<<endl<<a%b;
	return 0;
}