高精度神游

• 高精度版子
• 高精度类

高精度版子

#include<bits/stdc++.h>
using namespace std;
int op1[1000],op2[1000],c[1000];
string jia(string a,string b)
{
	int i,j,k=0;  
    int r=0;
    string ol="";
    for(i=a.size()-1,j=b.size()-1;i>=0&&j>=0;i--,j--)
	{  
        int p=(a[i]-'0')+(b[j]-'0')+r;    
        r=p/10;
        ol=ol+(char)((p%10)+'0');
		k++; 
    }  
    while(i>=0)
	{   //如果b中的数加完了  
        int p=(a[i]-'0')+r;  
        r=p/10;  
        ol=ol+(char)((p%10)+'0'); 
		k++; 
        i--;  
    }  
    while(j>=0)
	{    //如果a中的数加完了  
        int p=(b[j]-'0')+r;  
        r=p/10;  
        ol=ol+(char)((p%10)+'0');  
        k++;
        j--;  
    }  
    if(r)
	{      //判断最高位有没有进位  
        ol=ol+(char)(r+'0');  
        k++;
    }  
    reverse(ol.begin(),ol.end());
    return ol; 
}
int bi(string s1,string s2)
{
	if(s1.size()>s2.size())
	return 233;
	if(s1.size()<s2.size())
	return 2333;
	for(int i=0;i<s1.size();i++)
	{
		if(s1[i]>s2[i])
		return 233;
		if(s1[i]<s2[i])
		return 2333;
	}
	return 233;
} 
string jian(string a,string b)
{
	string ol;
	op1[0]=a.length();
  	for(int i=1;i<=op1[0];i++)  
    op1[i]=a[op1[0]-i]-'0';  
	op2[0]=b.length();
	for(int i=1;i<=op2[0];i++)  
	op2[i]=b[op2[0]-i]-'0'; 
 	if((bi(a,b))==233) 
	{
		for(int i=1;i<=op1[0];i++)
		{
			op1[i]-=op2[i];
			if(op1[i]<0)
			{
				op1[i+1]--;
				op1[i]+=10;
			}
		}
    	op1[0]++; 
    	while(!op1[op1[0]]&&op1[0]>1)
    	op1[0]--;
    	for(int i=op1[0];i>=1;i--)  
      	ol=ol+(char)(op1[i]+'0'); 
    }                            
	else
	{  
		cout<<'-';
    	for(int i=1;i<=op2[0];i++)
		{
			op2[i]-=op1[i];
			if(op2[i]<0)
			{
				op2[i+1]--;
				op2[i]+=10;
			}
		}
    	op2[0]++;
    	while(!op2[op2[0]]&&op2[0]>1)
    	op2[0]--;
    	for(int i=op2[0];i>=1;i--)  
      	ol=ol+(char)(op2[i]+'0');          
  }  
  return ol;
}
string cheng(string a,string b)
{
	string ol;
	op1[0]=a.length();
  	for(int i=1;i<=op1[0];i++)  
    op1[i]=a[op1[0]-i]-'0';  
	op2[0]=b.length();
	for(int i=1;i<=op2[0];i++)  
	op2[i]=b[op2[0]-i]-'0'; 
	memset(c,0,sizeof(c));
  	for(int i=1;i<=op1[0];i++)
    for(int j=1;j<=op2[0];j++)  
    {
    	c[i+j-1]+=op1[i]*op2[j];  
    	c[i+j]+=c[i+j-1]/10;  
    	c[i+j-1]%=10;     
    }  
  	int len=op1[0]+op2[0]+1;
  	while((c[len]==0)&&(len>1))
	len--;
  	for(int i=len;i>=1;i--)  
    ol=ol+(char)(c[i]+'0');
	return ol; 
}
int main()
{
//	freopen("sub.in","r",stdin);
//	freopen("sub.out","w",stdout);
	string a,b;
	cin>>a>>b;
	cout<<jia(a,b)<<endl;
	cout<<jian(a,b)<<endl;
	cout<<cheng(a,b)<<endl;
	return 0;
}

高精度版子要把我搞傻了，以后直接用就好了，除法几乎是不用的所有在此就不写了

更新板子

#include<bits/stdc++.h>
using namespace std;
vector<int>op1,op2;
vector<int> jia(vector<int>a,vector<int>b)
{
    vector<int>c;
    int t=0;
    for(int i=0;i<a.size();i++)
    {
        t+=a[i];
        if(i<b.size())
        t+=b[i];
        c.push_back(t%10);
        t/=10;
    }
    if(t)
    c.push_back(t);
    return c;
}
vector<int> jian(vector<int>a,vector<int>b)
{
    vector<int>c;
    int t=0;
    for(int i=0;i<a.size();i++)
    {
        t=a[i]-t;
        if(i<b.size())
        t-=b[i];
        c.push_back((t+10)%10);
        if(t<0)
        t=1;
        else
        t=0;
    }
    while(c.size()>1&&c.back()==0)
    c.pop_back();
    return c;
}
vector<int> cheng(vector<int>a,long long b)
{
    vector<int>c;
    long long t=0;
    for(int i=0;i<a.size()||t;i++)
    {
        if(i<a.size())
        t+=a[i]*b;
        c.push_back(t%10);
        t/=10;
    }
    return c;
    
}
int main()
{
    //加
    // string s,ss;
    // cin>>s;
    // for(int i=s.size()-1;i>=0;i--)
    // {
    //     int u=s[i]-'0';
    //     op1.push_back(u);
    // }
    // cin>>ss;
    // for(int i=ss.size()-1;i>=0;i--)
    // {
    //     int u=ss[i]-'0';
    //     op2.push_back(u);
    // }
    // bool p=0;
    // vector<int>ans;
    // ans=jia(op1,op2);
    // for(int i=ans.size()-1;i>=0;i--)
    // cout<<ans[i];
    //减
    // if(s.size()>ss.size())
    // {
    //     ans=jian(op1,op2);
    // }
    // if(s.size()<ss.size())
    // {
    //     ans=jian(op2,op1);
    //     p=1;
    // }
    // if(s.size()==ss.size())
    // {
    //     bool pp=0;
    //     for(int i=0;i<s.size();i++)
    //     {
    //         if(s[i]>ss[i])
    //         {
    //             pp=1;
    //             break;
    //         }
    //         if(s[i]<ss[i])
    //         {
    //             pp=0;
    //             break;
    //         }
    //     }
    //     if(pp)
    //     {
    //         ans=jian(op1,op2);
    //     }
    //     else
    //     {
    //         ans=jian(op2,op1);
    //         p=1;
    //     }
    // }
    // if(p)
    // {
    //     if(ans[ans.size()-1]!=0)
    //     cout<<'-';
    //     for(int i=ans.size()-1;i>=0;i--)
    //     cout<<ans[i];
    // }
    // else
    // {
    //     for(int i=ans.size()-1;i>=0;i--)
    //     cout<<ans[i];
    // }
    //乘
    // vector<int>ans;
    // string s,ss;
    // cin>>s;
    // for(int i=s.size()-1;i>=0;i--)
    // {
    //     int u=s[i]-'0';
    //     op1.push_back(u);
    // }
    // long long k;
    // cin>>k;
    // ans=cheng(op1,k);
    // for(int i=ans.size()-1;i>=0;i--)
    // {
    //     cout<<ans[i];
    // }
}

高精度类

#include<bits/stdc++.h>
  using namespace std;

#define Abigail inline void
typedef long long LL;
#define m(s) memset(s,0,sizeof(s))

const int N=20000;      //这个数不宜太大，否则会爆栈

struct bigint{

  int v[N+9],len;
  
  bigint(){m(v);len=0;}
  
  bigint(const char *c){      //O(n)
  	*this=bigint();
  	len=strlen(c);
    for (int i=1;i<=len;++i)
      v[len-i+1]=c[i-1]-'0';
    while (v[len]==0&&len>1) --len;
  }
  
  bigint(const string &s){      //O(n)
  	*this=bigint();
  	len=s.size();
  	for (int i=1;i<=len;++i)
  	  v[len-i+1]=s[i-1]-'0';
  	while (v[len]==0&&len>1) --len;
  }
  
  bigint(int x){      //O(n)
    *this=bigint();
    for (;x;x/=10) v[++len]=x%10;
    while (v[len]==0&&len>1) --len;
  }
  
  bigint(LL x){       //O(n)
  	*this=bigint();
  	for (;x;x/=10) v[++len]=x%10;
  	while (v[len==0]&&len>1) --len;
  }
  
  friend istream &operator >> (const istream &in,bigint &p){      //O(n)
  	char c=getchar();
  	p=bigint();
  	while (c<'0'||c>'9') c=getchar();
  	for (;c<='9'&&c>='0';c=getchar()) p.v[++p.len]=c-'0';
  	for (int i=1;i<=p.len>>1;++i)
  	  swap(p.v[i],p.v[p.len-i+1]);
  	while (p.v[p.len==0]&&p.len>1) --p.len;
  }
  
  friend ostream &operator << (const ostream &out,const bigint &p){      //O(n)
  	for (int i=p.len;i>=1;--i)
	  putchar(p.v[i]+'0');
  }
  
  bigint operator = (const char *c){*this=bigint(c);}      //O(n)
  bigint operator = (const string &s){*this=bigint(s);}      //O(n)
  bigint operator = (int x){*this=bigint(x);}      //O(n)
  bigint operator = (LL x){*this=bigint(x);}      //O(n)
  
  bool operator < (const bigint &p)const{      //O(n)
  	if (len^p.len) return len<p.len;
  	for (int i=len;i>=1;--i)
  	  if (v[i]^p.v[i]) return v[i]<p.v[i];
  	return false;
  }
  
  bool operator >= (const bigint &p)const{return !(*this<p);}      //O(n)
  bool operator > (const bigint &p)const{return p<*this;}      //O(n)
  bool operator <= (const bigint &p)const{return !(p<*this);}      //O(n)
  bool operator == (const bigint &p)const{return *this<=p&&*this>=p;}      //O(n)
  bool operator != (const bigint &p)const{return !(*this==p);}      //O(n)
  
  bigint operator + (const bigint &p)const{      //O(n)
    bigint ans=bigint();
    ans.len=max(len,p.len);
    for (int i=1;i<=ans.len;++i){
      ans.v[i]+=v[i]+p.v[i];
      while (ans.v[i]>=10) ans.v[i]-=10,++ans.v[i+1];
    }
    for (;ans.v[ans.len+1];++ans.len)
      while (ans.v[ans.len]>=10) ans.v[ans.len]-=10,++ans.v[ans.len+1];
    return ans;
  }
  
  bigint &operator += (const bigint &p){return *this=*this+p;}      //O(n)
  
  bigint operator - (const bigint &p)const{      //O(n)
    bigint ans=bigint();
    ans.len=len;
    for (int i=1;i<=ans.len;++i){
      ans.v[i]=ans.v[i]+v[i]-p.v[i];
	  while (ans.v[i]<0) ans.v[i]+=10,--ans.v[i+1]; 
    }
    for (;!ans.v[ans.len]&&ans.len>1;--ans.len);
    return ans;
  }
  
  bigint &operator -= (const bigint &p){return *this=*this-p;}      //O(n)
  
  bigint operator * (const bigint &p)const{      //O(n^2)
    bigint ans=bigint();
    ans.len=len+p.len;
    for (int i=1;i<=len;++i)
      for (int j=1;j<=p.len;++j){
        ans.v[i+j-1]+=v[i]*p.v[j];
        if (ans.v[i+j-1]>=10) ans.v[i+j]+=ans.v[i+j-1]/10,ans.v[i+j-1]%=10;
      }
    while (!ans.v[ans.len]&&ans.len>1) --ans.len;
    return ans;
  }
  
  bigint &operator *= (const bigint &p){return *this=*this*p;}      //O(n^2)
  
  bigint operator *(const int &p)const{      //O(n)
  	bigint ans=bigint();
  	ans.len=len+10;
  	for (int i=1;i<=ans.len;++i){
  	  ans.v[i]+=v[i]*p;
	  if (ans.v[i]>=10) ans.v[i+1]+=ans.v[i]/10,ans.v[i]%=10;
	}
	while (!ans.v[ans.len]&&ans.len>1) --ans.len;
	return ans;
  }
  
  bigint &operator *= (const int &p){return *this=*this*p;}      //O(n)
  
  bigint operator / (const int &p)const{      //O(n)
    bigint ans=bigint();
    int now=0;
    ans.len=len;
    for (int i=len;i>=1;--i){
      now=now*10+v[i];
      while (now>=p) now-=p,++ans.v[i];
    }
    while (!ans.v[ans.len]&&ans.len>1) --ans.len;
    return ans;
  }
  
  bigint &operator /= (const int &p){return *this=*this/p;}      //O(n)
  
  bigint operator / (const bigint &p)const{      //O(n^2)
    bigint ans=bigint(),now=bigint(0);
    ans.len=len;
    for (int i=len;i>=1;--i){
      now=now*10+v[i];
      while (now>=p) now-=p,++ans.v[i];
    }
    while (!ans.v[ans.len]&&ans.len>1) --ans.len;
    return ans;
  }
  
  bigint &operator /= (const bigint &p){return *this=*this/p;}      //O(n^2)
  
  bigint operator % (const int &p)const{      //O(n)
    int now=0;
    for (int i=len;i>=1;--i){
      now=now*10+v[i];
      while (now>=p) now-=p;
	}
	return now;
  }
  
  bigint &operator %= (const int &p){return *this=*this%p;}      //O(n)
  
  bigint operator % (const bigint &p)const{      //O(n^2)
    bigint now=bigint(0);
    for (int i=len;i>=1;--i){
      now=now*10+v[i];
      while (now>=p) now-=p;
    }
    return now;
  }
  
  bigint &operator %= (const bigint &p){return *this=*this%p;}      //O(n^2)
  
}a,b;

Abigail into(){
  cin>>a;cin>>b;
}

Abigail work(){
}

Abigail outo(){
  cout<<a+b;puts("");
  (a>=b)?cout<<a-b:cout<<'-'<<b-a;puts("");
  cout<<a*b;puts("");
  cout<<a/b;puts("");
  cout<<a%b;puts("");
}

int main(){
  into();
  work();
  outo();
  return 0;
}
--------------------- 
作者：hezlik 
来源：CSDN 
原文：https://blog.csdn.net/hzk_cpp/article/details/86673916 
版权声明：本文为博主原创文章，转载请附上博文链接！

高精度类出自hzk