高精度乘法
/*
支持高精度与高精度的加减乘除和取余。
支持高精度乘单精度 不过要单精度在右边。
支持所有比较。
支持cin和cout
*/
#include<iostream>
#include<iomanip>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<memory>
#include<algorithm>
#include<string>
#include<climits>
using namespace std;
const int THP_MAXLEN=20050;
const int THP_MAXSTRLEN=20050; //这两个常量都是必须要的,表示高精度长度.
const int L0=10000; //每一位存4位数
char s[THP_MAXLEN*4]; //int给高精度赋值用
class thp //高精度类的名称
{
friend istream& operator>>(istream&,thp&); /*输入运算符友元*/
friend ostream& operator<<(ostream&,const thp&); /*输出运算符友元*/
friend const thp operator-(const thp&,const thp&);
friend const thp operator+(const thp&,const thp&);
friend const thp operator*(const thp&,int); /*高精度乘单精度*/
friend const thp operator*(const thp&,const thp&);
friend const thp operator/(const thp&,const thp&);
friend void thpdiv(const thp&,const thp&,thp&,thp&);
friend const thp operator%(const thp&,const thp&);
public:
const thp& operator=(const thp&);
const thp& operator=(const char*);
const thp& operator=(int num);
bool operator==(const thp&)const;
bool operator>=(const thp&)const;
bool operator<=(const thp&)const;
inline bool operator!=(const thp&)const;
bool operator>(const thp&)const;
bool operator<(const thp&)const;
inline void shl(const int);
const thp& operator ++ ();
inline void makeempty();
const char *tostr()const;
inline thp& operator-=(const thp&);
thp();
thp(const char*);
const int thpstd();
protected: //几个数据项,_high表示位数。
int _data[THP_MAXLEN],_high,_sign; //_data 是每位的存储。
};
const int thp::thpstd()
{ int i;
for(i=0;i<=_high;i++)
{ while(_data[i]<0)
{ _data[i]+=L0;
_data[i+1]--;
}
}
return(0);
}
const thp operator % (const thp &a,const thp &b)
{ thp re1,re2;
thpdiv(a,b,re1,re2);
return(re2);
}
const thp& thp::operator ++ ()
{ _data[0]++;
if(_data[0]>=L0)this->thpstd();
return(*this);
}
void thp::shl(const int n)
{ int i;
for(i=_high;i>=0;i--)
{ _data[i+n]=_data[i];
}
_high+=n;
if(_data[_high]==0)_high=0;
}
thp& thp::operator -= (const thp &o)
{ int tint,i,len;
for(i=0;i<=_high;i++)
{ tint=_data[i]-o._data[i];
if(tint<0)
{ tint+=L0;
_data[i+1]--;
}
_data[i]=tint;
}
for(len=this->_high;len>=0;len--)
{ if(_data[len]!=0)break;
if(len==0)break;
}
_high=len;
return(*this);
}
void thpdiv(const thp &a,const thp &b,thp &c,thp &d)
{ int i;
d.makeempty();
c.makeempty();
for(i=a._high;i>=0;i--)
{ d.shl(1);
d._data[0]=a._data[i];
while(b<=d)
{ d-=b;
c._data[i]++;
}
if(i==0)break;
}
c._high=0;
for(i=a._high;i>0;i--)
{ if(c._data[i]!=0)
{ c._high=i;break;
}
}
}
inline bool thp::operator != (const thp &o)const
{ return(!(0==memcmp(this,&o,sizeof(thp))));
}
bool thp::operator == (const thp &o)const
{ return(0==memcmp(this,&o,sizeof(thp)));
}
inline bool thp::operator < (const thp &o)const
{ int i;
if(*this==o)return(false);
{ if(this->_high!=o._high)return(this->_high<o._high);
for(i=this->_high;i>=0;i--)
{ if(this->_data[i]!=o._data[i])return(this->_data[i]<o._data[i]);
if(i==0)break;
}
}
return(false);
}
bool thp::operator > (const thp &o)const
{ if(*this==o)return(false);
return(!(*this<o));
}
bool thp::operator <= (const thp &o)const
{ return(*this<o||*this==o);
}
bool thp::operator >= (const thp &o)const
{ return(!(*this<o));
}
inline int max(int a,int b)
{ return(a>b?a:b);
}
thp::thp()
{ makeempty();
}
thp::thp(const char *s)
{ *this=s;
}
const thp operator-(const thp &a,const thp &b)
{ int i,len,tint;
thp re;
len=max(a._high,b._high);
for(i=0;i<=len;i++)
{ tint=a._data[i]-b._data[i]+re._data[i];
if(tint<0)
{ tint+=L0;
re._data[i+1]--;
}
re._data[i]=tint;
}
while(len>0&&re._data[len]<1)len--;
re._high=len;
return(re);
}
const thp operator/(const thp &a,const thp &b)
{ thp re1,re2;
thpdiv(a,b,re1,re2);
return(re1);
}
const thp operator*(const thp &a,const thp &b)
{ int i,j,tint,len;
thp re;
for(i=0;i<=a._high;i++)
for(j=0;j<=b._high;j++)
{ tint=a._data[i]*b._data[j]+re._data[i+j];
re._data[i+j]=tint%L0;
re._data[i+j+1]+=tint/L0;
}
len=i+j;
if(re._data[len+1]!=0)len++;
re._high=len;
return(re);
}
/*高精度乘以低精度(注意:必须是bign*int顺序不能颠倒,要么会与高精度乘高精度发生冲突*/
const thp operator*(const thp& a,int b)
{
int i,t,c=0;
thp res;
for(i=0;i<=a._high;i++)
{
t=a._data[i]*b+c;
res._data[i]=t%L0;
c=t/L0;
}
res._high=a._high;
while(c!=0)
{
res._data[i++]=c%L0;
c/=L0;
res._high++;
}
return res;
}
/*(可选)加法运算符重载*/
const thp operator+(const thp &a,const thp &b)
{ int i,len,tint;
thp re;
len=max(a._high,b._high);
for(i=0;i<=len;i++)
{ tint=a._data[i]+b._data[i]+re._data[i];
re._data[i]=tint%L0;
re._data[i+1]=tint/L0;
}
if(re._data[len+1]!=0)len++;
re._high=len;
return(re);
}
const char *thp::tostr()const
{ char *re;
char ts[5];
int i,j,tint;
re=(char *)malloc(THP_MAXSTRLEN);
memset(ts,0,sizeof(ts));
memset(re,0,THP_MAXSTRLEN);
for(i=_high;i>=0;i--)
{ tint=_data[i];
for(j=0;j<4;j++)
{ ts[3-j]=tint%10+'0';
tint/=10;
}
strcat(re,ts);
}
while(strlen(re)>1&&*re=='0')re++;
return(re);
}
inline void thp::makeempty()
{ memset(this,0,sizeof(thp));}
const thp& thp::operator = (const char *s)
{ char ts[5];
memset(ts,0,sizeof(ts));
int len,i;
makeempty();
len=strlen(s);
_high=(len-1)/4;
i=(len-1)%4+1;
strncpy(ts,s,i);
s+=i;
_data[_high]=atoi(ts);
i=_high;
while(i>0)
{ i--;
memset(ts,0,sizeof(ts));
strncpy(ts,s,4);
s+=4;
_data[i]=atoi(ts);
}
return(*this);
}
const thp& thp::operator = (const thp &hp)
{ memcpy(this,&hp,sizeof(thp));
return(*this);
}
const thp& thp::operator=(const int num)
{
memset(s,0,sizeof(s));
sprintf(s,"%d",num);
*this=s;
return *this;
}
istream& operator>>(istream &in,thp& x)
{
string s;
in>>s;
x=s.c_str();
return in;
}
ostream& operator<<(ostream &out,const thp& x)
{
out<<x.tostr();
return out;
}
int main()
{
//freopen("P1109.in","r",stdin);
thp a,b,c;
cin>>a>>b;
c=a/b;
cout<<c<<endl;
return 0;
}