高精度类模板

最新推荐文章于 2025-01-10 17:39:25 发布
原创 最新推荐文章于 2025-01-10 17:39:25 发布 · 281 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

一个用来屯高精度类板子的模板.

基本都是用最朴素的万进制压位实现的高精度，乘法没有FFT，除法没有倍增.

代码如下：

typedef long long LL;
#define memset(a) memset(a,0,sizeof(a))

struct unsigned_bigint{
  
  int a[N+9],n;
  
  unsigned_bigint(int X=0){memset(a);for (n=0;X;X/=10000) a[++n]=X%10000;if (!n) n=1;}
  unsigned_bigint(LL X){memset(a);for (n=0;X;X/=10000) a[++n]=X%10000;if (!n) n=1;}
  
  unsigned_bigint(char *S,int N){
    memset(a);n=N;
	for (int i=4;i<n+4;i+=4){
	  int t=i/4;
	  if (i<n+1) a[t]=S[n-i+1]-'0';
	  if (i<n+2) a[t]=a[t]*10+S[n-i+2]-'0';
	  if (i<n+3) a[t]=a[t]*10+S[n-i+3]-'0';
	  if (i<n+4) a[t]=a[t]*10+S[n-i+4]-'0';
    }
	for (;!a[n];--n);
	if (!n) n=1;
  }
  
  unsigned_bigint(char *S){
    memset(a);n=strlen(S+1);
	for (int i=4;i<n+4;i+=4){
	  int t=i>>2;
	  if (i<n+1) a[t]=S[n-i+1]-'0';
	  if (i<n+2) a[t]=a[t]*10+S[n-i+2]-'0';
	  if (i<n+3) a[t]=a[t]*10+S[n-i+3]-'0';
	  if (i<n+4) a[t]=a[t]*10+S[n-i+4]-'0';
    }
	for (;!a[n];--n);
	if (!n) n=1;
  }
  
  unsigned_bigint(string S){
    memset(a);n=S.size();
	for (int i=4;i<n+4;i+=4){
	  int t=i>>2;
	  if (i<=n) a[t]=S[n-i]-'0';
	  if (i<=n+1) a[t]=a[t]*10+S[n-i+1]-'0';
	  if (i<=n+2) a[t]=a[t]*10+S[n-i+2]-'0';
	  if (i<=n+3) a[t]=a[t]*10+S[n-i+3]-'0';
    }
	for (;!a[n];--n);
	if (!n) n=1;
  }
  
  int &operator [] (const int &p){return a[p];}
  
  friend istream &operator >> (istream &in,unsigned_bigint &p){
    string s;
	in>>s;
	p=unsigned_bigint(s);
	return in;
  }
  
  friend ostream &operator << (ostream &out,const unsigned_bigint &p){
  	out<<p.a[p.n];
  	for (int i=p.n-1;i>=1;--i){
  	  if (p.a[i]<1000) out<<0;
  	  if (p.a[i]<100) out<<0;
  	  if (p.a[i]<10) out<<0;
  	  out<<p.a[i];
  	}
    return out;
  }
  
  bool operator < (const unsigned_bigint &p)const{
    if (n^p.n) return n<p.n;
    for (int i=n;i>=0;--i)
      if (a[i]^p.a[i]) return a[i]<p.a[i];
    return 0;
  }
  
  bool operator > (const unsigned_bigint &p)const{return p<*this;}
  bool operator <= (const unsigned_bigint &p)const{return !(*this>p);}
  bool operator >= (const unsigned_bigint &p)const{return !(*this<p);}
  bool operator == (const unsigned_bigint &p)const{return *this<=p&&*this>=p;}
  bool operator != (const unsigned_bigint &p)const{return *this<p||*this>p;}
  bool operator < (const int &p)const{return *this<unsigned_bigint(p);}
  bool operator < (const LL &p)const{return *this<unsigned_bigint(p);}
  bool operator < (const string &p)const{return *this<unsigned_bigint(p);}
  bool operator < (const char *p)const{return *this<unsigned_bigint(p);}
  bool operator > (const int &p)const{return *this>unsigned_bigint(p);}
  bool operator > (const LL &p)const{return *this>unsigned_bigint(p);}
  bool operator > (const string &p)const{return *this>unsigned_bigint(p);}
  bool operator > (const char *p)const{return *this>unsigned_bigint(p);}
  bool operator <= (const int &p)const{return *this<=unsigned_bigint(p);}
  bool operator <= (const LL &p)const{return *this<=unsigned_bigint(p);}
  bool operator <= (const string &p)const{return *this<=unsigned_bigint(p);}
  bool operator <= (const char *p)const{return *this<=unsigned_bigint(p);}
  bool operator >= (const int &p)const{return *this>=unsigned_bigint(p);}
  bool operator >= (const LL &p)const{return *this>=unsigned_bigint(p);}
  bool operator >= (const string &p)const{return *this>=unsigned_bigint(p);}
  bool operator >= (const char *p)const{return *this>=unsigned_bigint(p);}
  bool operator == (const int &p)const{return *this==unsigned_bigint(p);}
  bool operator == (const LL &p)const{return *this==unsigned_bigint(p);}
  bool operator == (const string &p)const{return *this==unsigned_bigint(p);}
  bool operator == (const char *p)const{return *this==unsigned_bigint(p);}
  bool operator != (const int &p)const{return *this!=unsigned_bigint(p);}
  bool operator != (const LL &p)const{return *this!=unsigned_bigint(p);}
  bool operator != (const string &p)const{return *this!=unsigned_bigint(p);}
  bool operator != (const char *p)const{return *this!=unsigned_bigint(p);}
  
  unsigned_bigint operator + (const unsigned_bigint &p)const{
  	unsigned_bigint res;
  	res.n=max(n,p.n);
  	for (int i=1;i<=res.n;++i){
  	  res.a[i]+=a[i]+p.a[i];
  	  if (res.a[i]>=10000) ++res.a[i+1],res.a[i]-=10000;
  	}
  	if (res.a[res.n+1]) ++res.n;
  	return res;
  }
  
  unsigned_bigint operator + (const int &p)const{return *this+unsigned_bigint(p);}
  unsigned_bigint operator + (const LL &p)const{return *this+unsigned_bigint(p);}
  unsigned_bigint operator + (const char *s)const{return *this+unsigned_bigint(s);}
  unsigned_bigint operator + (const string s)const{return *this+unsigned_bigint(s);}
  unsigned_bigint &operator += (const unsigned_bigint &p){return *this=*this+p;}
  unsigned_bigint &operator += (const int &p){return *this=*this+p;}
  unsigned_bigint &operator += (const LL &p){return *this=*this+p;}
  unsigned_bigint &operator += (const char &p){return *this=*this+p;}
  unsigned_bigint &operator += (const string &p){return *this=*this+p;}
  
  unsigned_bigint operator - (const unsigned_bigint &p)const{
  	unsigned_bigint res;
  	res.n=n;
    for (int i=1;i<=res.n;++i){
      res.a[i]+=a[i]-p.a[i];
	  if (res.a[i]<0) --res.a[i+1],res.a[i]+=10000;
    }
    for (;res.n>1&&!res.a[res.n];--res.n);
    return res;
  }
  
  unsigned_bigint operator - (const int &p)const{return *this-unsigned_bigint(p);}
  unsigned_bigint operator - (const LL &p)const{return *this-unsigned_bigint(p);}
  unsigned_bigint operator - (const char *s)const{return *this-unsigned_bigint(s);}
  unsigned_bigint operator - (const string s)const{return *this-unsigned_bigint(s);}
  unsigned_bigint &operator -= (const unsigned_bigint &p){return *this=*this-p;}
  unsigned_bigint &operator -= (const int &p){return *this=*this-p;}
  unsigned_bigint &operator -= (const LL &p){return *this=*this-p;}
  unsigned_bigint &operator -= (const char &p){return *this=*this-p;}
  unsigned_bigint &operator -= (const string &p){return *this=*this-p;}
  
  unsigned_bigint operator * (const unsigned_bigint &p)const{
    unsigned_bigint res;
    res.n=n+p.n-1;
    for (int i=1;i<=n;++i)
	  for (int j=1;j<=p.n;++j){
	    res.a[i+j-1]+=a[i]*p.a[j];
	    res.a[i+j]+=res.a[i+j-1]/10000;res.a[i+j-1]%=10000;
	  }
    if (res.a[res.n+1]) ++res.n;
    for (;!res.a[res.n]&&res.n>1;--res.n);
    return res;
  }
  
  unsigned_bigint operator * (const int &p)const{
    if (p>100000) return *this*unsigned_bigint(p);
    unsigned_bigint res;
    res.n=n+8;
	for (int i=1;i<=res.n;++i){
	  res.a[i]+=a[i]*p;
	  res.a[i+1]+=res.a[i]/10000;res.a[i]%=10000;
	}
	for (;!res.a[res.n]&&res.n>1;--res.n);
	return res;
  }
  
  unsigned_bigint operator * (const LL &p)const{return *this*unsigned_bigint(p);}
  unsigned_bigint operator * (const char *s)const{return *this*unsigned_bigint(s);}
  unsigned_bigint operator * (const string s)const{return *this*unsigned_bigint(s);}
  unsigned_bigint &operator *= (const unsigned_bigint &p){return *this=*this*p;}
  unsigned_bigint &operator *= (const int &p){return *this=*this*p;}
  unsigned_bigint &operator *= (const LL &p){return *this=*this*p;}
  unsigned_bigint &operator *= (const char &p){return *this=*this*p;}
  unsigned_bigint &operator *= (const string &p){return *this=*this*p;}
  
  unsigned_bigint operator / (const unsigned_bigint &p)const{
    unsigned_bigint res,now=unsigned_bigint(0);
    for (int i=n;i>=1;--i){
      now=now*10000+a[i];
      for (;now>=p;now-=p) ++res.a[i];
    }
    for (res.n=n;!res.a[res.n]&&res.n>1;--res.n);
    return res;
  }
  
  unsigned_bigint operator / (const int &p)const{
    if (p>100000) return *this/unsigned_bigint(p);
    unsigned_bigint res;
    int now=0;
    for (int i=n;i>=1;--i){
      now=now*10000+a[i];
      res.a[i]=now/p;now%=p;
    }
    for (res.n=n;!res.a[res.n]&&res.n>1;--res.n);
    return res;
  }
  
  unsigned_bigint operator / (const LL &p)const{return *this/unsigned_bigint(p);}
  unsigned_bigint operator / (const char *s)const{return *this/unsigned_bigint(s);}
  unsigned_bigint operator / (const string s)const{return *this/unsigned_bigint(s);}
  unsigned_bigint &operator /= (const unsigned_bigint &p){return *this=*this/p;}
  unsigned_bigint &operator /= (const int &p){return *this=*this/p;}
  unsigned_bigint &operator /= (const LL &p){return *this=*this/p;}
  unsigned_bigint &operator /= (const char &p){return *this=*this/p;}
  unsigned_bigint &operator /= (const string &p){return *this=*this/p;}

  unsigned_bigint operator % (const unsigned_bigint &p)const{
    unsigned_bigint res=unsigned_bigint(0);
    for (int i=n;i>=1;--i){
      res=res*10000+a[i];
      for (;res>=p;res-=p);
    }
    return res;
  }
  
  unsigned_bigint operator % (const int &p)const{
    if (p>100000) return *this%unsigned_bigint(p);
    int res=0;
    for (int i=n;i>=1;--i) res=(res*10000+a[i])%p;
    return unsigned_bigint(res);
  }
  
  unsigned_bigint operator % (const LL &p)const{return *this%unsigned_bigint(p);}
  unsigned_bigint operator % (const char *s)const{return *this%unsigned_bigint(s);}
  unsigned_bigint operator % (const string s)const{return *this%unsigned_bigint(s);}
  unsigned_bigint &operator %= (const unsigned_bigint &p){return *this=*this%p;}
  unsigned_bigint &operator %= (const int &p){return *this=*this%p;}
  unsigned_bigint &operator %= (const LL &p){return *this=*this%p;}
  unsigned_bigint &operator %= (const char &p){return *this=*this%p;}
  unsigned_bigint &operator %= (const string &p){return *this=*this%p;}
  
  int Get_int(){
    int res=0;
    for (int i=n;i>=1;--i) res=res*10000+a[i];
    return res;
  }
  
};

unsigned_bigint operator * (const int &k,const unsigned_bigint &a){return a*k;}

struct bigint{
  
  int opt;
  unsigned_bigint a;
  
  bigint(int X=0){opt=X<0;a=unsigned_bigint(abs(X));}
  bigint(LL X){opt=X<0;a=unsigned_bigint(abs(X));}
  bigint(char *S,int N){opt=S[1]=='-';a=unsigned_bigint(S[1]=='-'?(S+1,N-1):(S,N));}
  bigint(char *S){opt=S[1]=='-';a=unsigned_bigint(S[1]=='-'?S+1:S);}
  bigint(string S){opt=S[0]=='-';if (S[0]=='-') S.erase(0,1);a=unsigned_bigint(S);}
  bigint(int Opt,unsigned_bigint A){opt=Opt;a=A;}
  int &operator [] (const int &p){return a[p];}
  friend istream &operator >> (istream &in,bigint &p){string s;in>>s;p=bigint(s);return in;}
  
  friend ostream &operator << (ostream &out,const bigint &p){
    if (p.opt&&(p.a.n^1||p.a.a[1]^0)) out<<'-';
	out<<p.a;
	return out;
  }
  
  bool operator < (const bigint &p)const{if (opt^p.opt) return opt>p.opt;return opt?a>p.a:a<p.a;}
  bool operator > (const bigint &p)const{return p<*this;}
  bool operator <= (const bigint &p)const{return !(*this>p);}
  bool operator >= (const bigint &p)const{return !(*this<p);}
  bool operator == (const bigint &p)const{return *this<=p&&*this>=p;}
  bool operator != (const bigint &p)const{return *this<p||*this>p;}
  bool operator < (const int &p)const{return *this<bigint(p);}
  bool operator < (const LL &p)const{return *this<bigint(p);}
  bool operator < (const string &p)const{return *this<bigint(p);}
  bool operator < (const char *p)const{return *this<bigint(p);}
  bool operator > (const int &p)const{return *this>bigint(p);}
  bool operator > (const LL &p)const{return *this>bigint(p);}
  bool operator > (const string &p)const{return *this>bigint(p);}
  bool operator > (const char *p)const{return *this>bigint(p);}
  bool operator <= (const int &p)const{return *this<=bigint(p);}
  bool operator <= (const LL &p)const{return *this<=bigint(p);}
  bool operator <= (const string &p)const{return *this<=bigint(p);}
  bool operator <= (const char *p)const{return *this<=bigint(p);}
  bool operator >= (const int &p)const{return *this>=bigint(p);}
  bool operator >= (const LL &p)const{return *this>=bigint(p);}
  bool operator >= (const string &p)const{return *this>=bigint(p);}
  bool operator >= (const char *p)const{return *this>=bigint(p);}
  bool operator == (const int &p)const{return *this==bigint(p);}
  bool operator == (const LL &p)const{return *this==bigint(p);}
  bool operator == (const string &p)const{return *this==bigint(p);}
  bool operator == (const char *p)const{return *this==bigint(p);}
  bool operator != (const int &p)const{return *this!=bigint(p);}
  bool operator != (const LL &p)const{return *this!=bigint(p);}
  bool operator != (const string &p)const{return *this!=bigint(p);}
  bool operator != (const char *p)const{return *this!=bigint(p);}
  bigint operator - (){return bigint(opt^1,a);}
  
  bigint operator + (const bigint &p)const{
    return opt==p.opt?bigint(opt,a+p.a):bigint(opt^a<p.a,a<p.a?p.a-a:a-p.a);
  }
  
  bigint operator + (const int &p)const{return *this+bigint(p);}
  bigint operator + (const LL &p)const{return *this+bigint(p);}
  bigint operator + (const char *s)const{return *this+bigint(s);}
  bigint operator + (const string s)const{return *this+bigint(s);}
  bigint &operator += (const bigint &p){return *this=*this+p;}
  bigint &operator += (const int &p){return *this=*this+p;}
  bigint &operator += (const LL &p){return *this=*this+p;}
  bigint &operator += (const char &p){return *this=*this+p;}
  bigint &operator += (const string &p){return *this=*this+p;}
  bigint operator - (const bigint &p)const{return *this+bigint(p.opt^1,p.a);}
  bigint operator - (const int &p)const{return *this-bigint(p);}
  bigint operator - (const LL &p)const{return *this-bigint(p);}
  bigint operator - (const char *s)const{return *this-bigint(s);}
  bigint operator - (const string s)const{return *this-bigint(s);}
  bigint &operator -= (const bigint &p){return *this=*this-p;}
  bigint &operator -= (const int &p){return *this=*this-p;}
  bigint &operator -= (const LL &p){return *this=*this-p;}
  bigint &operator -= (const char &p){return *this=*this-p;}
  bigint &operator -= (const string &p){return *this=*this-p;}
  bigint operator * (const bigint &p)const{return bigint(opt^p.opt,a*p.a);}
  bigint operator * (const int &p)const{return bigint(opt^p<0,a*abs(p));}
  bigint operator * (const LL &p)const{return *this*bigint(p);}
  bigint operator * (const char *s)const{return *this*bigint(s);}
  bigint operator * (const string s)const{return *this*bigint(s);}
  bigint &operator *= (const bigint &p){return *this=*this*p;}
  bigint &operator *= (const int &p){return *this=*this*p;}
  bigint &operator *= (const LL &p){return *this=*this*p;}
  bigint &operator *= (const char &p){return *this=*this*p;}
  bigint &operator *= (const string &p){return *this=*this*p;}
  bigint operator / (const bigint &p)const{return bigint(opt^p.opt,a/p.a);}
  bigint operator / (const int &p)const{return bigint(opt^p<0,a/abs(p));}
  bigint operator / (const LL &p)const{return *this/bigint(p);}
  bigint operator / (const char *s)const{return *this/bigint(s);}
  bigint operator / (const string s)const{return *this/bigint(s);}
  bigint &operator /= (const bigint &p){return *this=*this/p;}
  bigint &operator /= (const int &p){return *this=*this/p;}
  bigint &operator /= (const LL &p){return *this=*this/p;}
  bigint &operator /= (const char &p){return *this=*this/p;}
  bigint &operator /= (const string &p){return *this=*this/p;}
  bigint operator % (const bigint &p)const{return bigint(opt,a%p.a);}
  bigint operator % (const int &p)const{return bigint(opt,a%p);}
  bigint operator % (const LL &p)const{return *this%bigint(p);}
  bigint operator % (const char *s)const{return *this%bigint(s);}
  bigint operator % (const string s)const{return *this%bigint(s);}
  bigint &operator %= (const bigint &p){return *this=*this%p;}
  bigint &operator %= (const int &p){return *this=*this%p;}
  bigint &operator %= (const LL &p){return *this=*this%p;}
  bigint &operator %= (const char &p){return *this=*this%p;}
  bigint &operator %= (const string &p){return *this=*this%p;}
  int Get_int(){return a.Get_int()*(opt?-1:1);}
  
};

bigint operator * (const int &k,const bigint &a){return a*k;}
高精度模板
wood
07-19 1503
c++没有高精度类,很气,于是弄了一个高精度模板#include<cstdio> #include<iostream> #include<vector> #include<cstring> #define LL long long using namespace std; struct bigint{ static const int base=1000000000; static
C++高精度模板（加减乘除模）
02-04
C++竞赛高精度模板 优点：包含四则运算 抛弃传统数组，使用vector 缺点：乘法没有使用FFT算法，复杂度O(N^2) 在某些编辑器上可能无法使用资源中定义的常量，需要手动创建（CE的话可能是这个问题） 没有运算符...
【高精度算法C++模板】
最新发布
akiba-miku
01-10 730
高精度算法的C++模板
C++高精度模板
03-05
支持（无限）高精度加、减、乘、除、模、大于、小于、大于等于、小于等于、位移、等于、不等于、++、--，cin>>，cout 总之，一切int类型的运算都支持
C++ 高精度封装模板
08-27
此模板为已封装模板，包含 高精度的+，-，*，/，不包含小数 by LAZ
高精度算法类
05-18
经过实际项目检验的C++算法类，绝对可用。用法如下 char sz1[256]=""; char sz2[256]=""; puts("请输入两个数字:"); while(scanf("%s%s",sz1,sz2)!=-1) { CHighPrecisionCalculate n1(sz1); CHighPrecisionCalculate n2(sz2); CHighPrecisionCalculate n3; n3=n2; CHighPrecisionCalculate n4(n2); //printf("两数相加结果:\n%s\n",(n1+n2).ToString()); printf("两数相减结果:\n%s\n",(n1-n2).ToString()); //printf("两数相乘结果:\n%s\n",(n1*n2).ToString()); printf("两数相除结果:\n%s\n",(n1/n2).ToString()); printf("两数相除四舍五入结果:\n%s\n",(n1/n2).ToStringSpecifyPrecisionRound(5).c_str()); puts("请输入两个数字:"); } return 0;
高精度大数运算类
12-12
该大数运算类是一个支持超高精度和超大数的基本运算类，最高精度能够达到一百亿位有效数字，最大能够表示10的2147483648次方，支持基础的四则运算和比较运算。该类的特点是使用指数形式表示数据，应此空间占用少，运算速度比较快。该类库是基于MFC 的动态连接库，方便VS的开发环境。 该类库包含两个无符号整数类、两个有符号整数类和一个浮点数类，整数又分为带指数的和不带指数的两种，所以总共有不带指数的无符号整数类、带指数的无符号整数类、不带指数的有符号指数类、带指数的有符号指数类和浮点数类，不带指数的类用于循环计数等场合，这些场合通常不是10的整数倍，应此没有必要使用指数形式表示，带指数的类通常用于比较大的但是是10的整数倍，如光的速度等，使用带指数的类来计算即可节约存储空间，也可提高运算速度。
c++ 高精度类代码
05-18
c++ 高精度类代码，BigInt类，含+ - * / 等基本运算。
高精度模板总结
正在学算法的小朋友的博客
05-27 878
简要： 以下是我对高精度模板的总结，只有乘法和加法用了底层原理，底层原理是用c++来实现的，其余的采用的是stl方法，都是用Java来实现的。 高精度加法1： import java.util.*; import java.math.*; public class Main { public static void main(String[] args){ String t1; String t2; Scanner scan = new S
高精度运算类bign
乖兔子的专栏
12-13 2291
#include #include #include #include #include #include #include #include using namespace std; const int maxn = 1000; struct bign { int len, s[maxn]; //s是逆序存储 bign(){ m
高精度类 BigNumber
chrt's blog
11-17 3863
很少写这东西，昨天下午尝试了一下。本高精度类支持有/无符号大整数加、减、乘、比较，特点是简短。有符号整数采用补码实现。
高精度运算类(BigInteger,BigDecimal)
rui2yun的专栏
09-13 1832
 主类型    大小    最小值    最大值    封装器类型boolean    －    －    －    Boolean Char    16-bit    Unicode 0    Unicode 216- 1    Characterbyte    8-bit    -128    +127    ByteShort    16-bit    -215    +215?1    S
【转载】高精度类
weixin_30699443的博客
05-31 141
// //Search // //happyZYM 的博客 //题解 UVA10213 【How Many Pieces of Land ?】 // //2018-05-16 20:09:51thumb_up 0 //紫书上的思路很容易理解，但时间复杂度太高。在网上搜了半天终于在维基百科上搜到了O(1)算法。 以下证明过程摘自维基百科： pic // //即答案为...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值