高精度模板--zhengjun

置顶 已于 2022-05-28 14:33:40 修改
阅读量510 收藏 2
点赞数 6
分类专栏： 其他 文章标签： 高精度 快速幂 c++
于 2020-04-15 18:46:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_zjzj/article/details/105541753
版权

因为之前没有看到过既有负数，还可以压位的高精度运算，所以我就自己发一篇(原来这么简单，我 1 h 1h 1h就写好了)

如果有什么 b u g bug bug，请在评论区回复或私聊我，我周末会看的。

本模板支持 + , − , × , ÷ ,   m o d   , a b , a b   m o d   x +,-,\times,\div,\bmod,a^b,a^b \bmod x +,−,×,÷,mod,ab,abmodx

模板

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
struct bign {
#define maxn 10000
#define yawei 4
#define base 10000
	int num[maxn],len;
	bool flag;
	friend bign abs(const bign &x) {
		bign k=x;
		k.flag=1;
		return k;
	}
	friend void remove(bign &x) {
		while(x.num[x.len]==0&&x.len>1)x.len--;
	}
	bign() {
		memset(num,0,sizeof(num));
		flag=1;
		len=1;
	}
	bign(const int &x) {
		*this=bign();
		if(x) {
			int k=x;
			if(k<0)k=-k,flag=0;
			len=0;
			while(k) {
				num[++len]=k%base;
				k/=base;
			}
		}
	}
	bign(const char *x) {
		int l=strlen(x),s,t=0,p=0,k=1;
		*this=bign();
		if(x[0]=='-')flag=0,s=1;
		len=0;
		for(int i=l-1; i>=s; i--) {
			p+=k*(x[i]-'0');
			k*=10;
			t++;
			if(t==4) {
				t=0;
				num[++len]=p;
				p=0;
				k=1;
			}
		}
		if(p)num[++len]=p;
	}
	bign(const string x) {
		int l=x.length(),s=0,t=0,p=0,k=1;
		*this=bign();
		if(x[0]=='-')flag=0,s=1;
		len=0;
		for(int i=l-1; i>=s; i--) {
			p+=k*(x[i]-'0');
			k*=10;
			t++;
			if(t==yawei) {
				t=0;
				num[++len]=p;
				p=0;
				k=1;
			}
		}
		if(p)num[++len]=p;
	}
	bign operator = (const int &x) {
		return *this=bign(x);
	}
	bign operator = (const char *x) {
		return *this=bign(x);
	}
	bign operator = (const string &x) {
		return *this=bign(x);
	}
	bool operator < (const bign &x)const {
		if(flag!=x.flag)return flag<x.flag;
		if(len!=x.len)return (len<x.len)^flag^1;
		for(int i=len; i>=1; i--) {
			if(num[i]!=x.num[i]) {
				return (num[i]<x.num[i])^flag^1;
			}
		}
		return 0;
	}
	bool operator < (const int &x)const {
		return *this<bign(x);
	}
	bool operator > (const bign &x)const {
		return x<*this;
	}
	bool operator > (const int &x)const {
		return *this>bign(x);
	}
	bool operator <= (const bign &x)const {
		return !(*this>x);
	}
	bool operator <= (const int &x)const {
		return *this<=bign(x);
	}
	bool operator >= (const bign &x)const {
		return !(*this<x);
	}
	bool operator >= (const int &x)const {
		return *this>=bign(x);
	}
	bool operator == (const bign &x)const {
		if(flag!=x.flag)return 0;
		if(len!=x.len)return 0;
		for(int i=len; i>=1; i--) {
			if(num[i]!=x.num[i]) {
				return 0;
			}
		}
		return 1;
	}
	bool operator == (const int &x)const {
		return *this==bign(x);
	}
	bool operator != (const bign &x)const {
		return !(*this==x);
	}
	bool operator != (const int &x)const {
		return *this!=bign(x);
	}
	friend istream& operator >> (istream &in,bign &x) {
		string s;
		in>>s;
		x=s;
		return in;
	}
	friend ostream& operator << (ostream &out,const bign &x) {
		if(x.flag==0)out<<"-";
		out<<x.num[x.len];
		for(int i=x.len-1; i>=1; i--)printf("%04d",x.num[i]);
		return out;
	}
	bign operator - ()const {
		bign k=*this;
		k.flag^=1;
		return k;
	}
	bign operator + (const bign &x)const {
		if(flag&&x.flag) {
			bign k=bign();
			k.len=0;
			for(int i=1,g=0; g||i<=len||i<=x.len; i++) {
				int p=num[i]+x.num[i]+g;
				k.num[++k.len]=p%base;
				g=p/base;
			}
			return k;
		}
		if(flag&&!x.flag)return *this-(-x);
		if(!flag&&x.flag)return x-(-*this);
		return -((-x)+(-*this));
	}
	bign operator + (const int &x)const {
		return *this+bign(x);
	}
	bign operator += (const bign &x) {
		return *this=*this+x;
	}
	bign operator += (const int &x) {
		return *this+=bign(x);
	}
	bign operator ++() {
		return *this+=1;
	}
	bign operator ++(int) {
		bign k=*this;
		*this+=1;
		return k;
	}
	bign operator - (const bign &x)const {
		if(flag&&x.flag&&*this>=x) {
			bign k=bign();
			k.len=0;
			for(int i=1,g=0; g||i<=len; i++) {
				int p=num[i]-x.num[i]+g;
				if(p<0)g=-1;
				else g=0;
				k.num[++k.len]=(p%base+base)%base;
			}
			remove(k);
			return k;
		}
		if(flag&&x.flag)return -(x-*this);
		if(flag&&!x.flag)return *this+(-x);
		if(!flag&&x.flag)return -((-*this)+x);
		return (-x)-(-*this);
	}
	bign operator -= (const bign &x) {
		*this=*this-x;
		return *this;
	}
	bign operator -= (const int &x) {
		return *this-=bign(x);
	}
	bign operator -- () {
		return *this-=1;
	}
	bign operator -- (int) {
		bign k=*this;
		*this-=1;
		return k;
	}
	bign operator * (const bign &x)const {
		bign k;
		k.flag=(flag==x.flag);
		k.len=len+x.len+1;
		for(int i=1; i<=len; i++) {
			for(int j=1; j<=x.len; j++) {
				k.num[i+j-1]+=num[i]*x.num[j];
				k.num[i+j]+=k.num[i+j-1]/base;
				k.num[i+j-1]%=base;
			}
		}
		remove(k);
		return k;
	}
	bign operator * (const int &x)const {
		bign k=bign();
		k.len=0;
		long long t[maxn];
		memset(t,0,sizeof(t));
		for(int i=1;i<=len;i++)t[i]=num[i]*x;
		for(int i=1,g=0;i<=len||g;i++){
			k.num[++k.len]=(g+t[i])%base;
			g=(g+t[i])/base;
		}
		return k;
	}
	bign operator *= (const bign &x) {
		return *this=*this*x;
	}
	bign operator *= (const int &x) {
		return *this=*this*x;
	}
	bign operator / (const bign &x)const {
		if(x==0)return bign();
		bign k=bign(),a=bign();
		k.flag=(flag==x.flag);
		k.len=len;
		for(int i=len; i>=1; i--) {
			a=a*base+num[i];
			while(a>=abs(x)) {
				a-=abs(x);
				k.num[i]++;
			}
		}
		remove(k);
		return k;
	}
	bign operator / (const int &x)const {
		if(x==0)return bign();
		bign k=bign();
		int a=0;
		k.flag=(flag==(x>=0));
		k.len=len;
		for(int i=len; i>=1; i--) {
			a=a*base+num[i];
			k.num[i]=a/x;
			a%=x;
		}
		remove(k);
		return k;
	}
	bign operator /= (const bign &x) {
		return *this=*this/x;
	}
	bign operator /= (const int &x) {
		return *this=*this/x;
	}
	bign operator % (const bign &x)const {
		if(x==0)return bign();
		bign a=bign();
		for(int i=len; i>=1; i--) {
			a=a*base+num[i];
			while(a>=abs(x))a-=abs(x);
		}
		if(a==0)return a;
		if(flag&&x.flag)return a;
		if(flag&&!x.flag)return a-abs(x);
		if(!flag&&x.flag)return x-a;
		return -a;
	}
	bign operator % (const int &x)const {
		return *this%bign(x);
	}
	bign operator %= (const bign &x) {
		return *this=*this%x;
	}
	bign operator %= (const int &x) {
		return *this%=bign(x);
	}
	friend bign pow(const bign &x,const bign &y) {
		bign ans=1,cnt=x,w=y;
		while(w>0) {
			if(w%2==1)ans*=cnt;
			cnt*=cnt;
			w/=2;
		}
		return ans;
	}
	friend bign pow(const int &x,const bign &y) {
		bign ans=1,cnt=x,w=y;
		while(w>0) {
			if(w%2==1)ans*=cnt;
			cnt*=cnt;
			w/=2;
		}
		return ans;
	}
	friend bign pow(const bign &x,const int &y) {
		bign ans=1,cnt=x;
		int w=y;
		while(w) {
			if(w&1)ans*=cnt;
			cnt*=cnt;
			w>>=1;
		}
		return ans;
	}
	friend bign powmod(const bign &x,const bign &y,const bign &z) {
		bign ans=1,cnt=x,w=y;
		while(w>0) {
			if(w%2==1)ans=ans*cnt%z;
			cnt=cnt*cnt%z;
			w/=2;
		}
		return ans;
	}
	friend bign powmod(const int &x,const bign &y,const bign &z) {
		bign ans=1,cnt=x,w=y;
		while(w>0) {
			if(w%2==1)ans=ans*cnt%z;
			cnt=cnt*cnt%z;
			w/=2;
		}
		return ans;
	}
	friend bign powmod(const bign &x,const int &y,const bign &z) {
		bign ans=1,cnt=x;
		int w=y;
		while(w) {
			if(w&1)ans=ans*cnt%z;
			cnt=cnt*cnt%z;
			w>>=1;
		}
		return ans;
	}
	friend bign powmod(const bign &x,const bign &y,const int &z) {
		bign ans=1,cnt=x,w=y;
		while(w>0) {
			if(w%2==1)ans=ans*cnt%z;
			cnt=cnt*cnt%z;
			w/=2;
		}
		return ans;
	}
	friend bign powmod(const int &x,const bign &y,const int &z) {
		bign ans=1,cnt=x,w=y;
		while(w>0) {
			if(w%2==1)ans=ans*cnt%z;
			cnt=cnt*cnt%z;
			w/=2;
		}
		return ans;
	}
	friend bign powmod(const bign &x,const int &y,const int &z) {
		bign ans=1,cnt=x;
		int w=y;
		while(w) {
			if(w&1)ans=ans*cnt%z;
			cnt=cnt*cnt%z;
			w>>=1;
		}
		return ans;
	}
	friend bign max(const bign &x,const bign &y){
		return x>y?x:y;
	}
	friend bign min(const bign &x,const bign &y){
		return x<y?x:y;
	}
};
int main(){
	return 0;
}

如果有帮助，请给个赞呗(宣传一下也可以)！！！

谢谢-- zhengjun

A_zjzj
关注
专栏目录
（c++ oi）高精度计算板子
qq_61035309的博客
07-19 534
你敲三小时代码，能得到优雅的高精度板子。你等三年，却换不来低精度的爱情。
Learning Spatio-Temporal Transformer for Visual Tracking——精读笔记
学海无涯，快乐行舟
12-08 2252
本篇精读笔记，对原文重要部分做了严格翻译，如摘要和总结。对正文部分做了提炼，对重点部分突出标注。对参考文献做了分类。本文内容较长，如果时间有限可以直接跳到感兴趣的小节阅读。
高精度（模板）
Coco_T的博客
10-05 574
今天写了一道需要高精度的模板题 结果高精乘写错一句，调了1个小时。。。STO 所以写了一遍常用的高精度，在这里再简单说一下高精度的思路：高精加模拟竖式计算 注意每次累加的时候都要加上余数d高精减有一个额外操作：判断两数大小，确定答案符号 第一标准：长度 第二标准每一位数的大小 注意：因为在存贮的时候是倒叙存储，所以在对比的时候也要从高位到低位倒叙对比 模拟竖式计算 借位的时候容易出错
大数模板
weixin_30372371的博客
09-17 97
1 大数： 2 #include <stdio.h> 3 #include <string.h> 4 #include <stdlib.h> 5 #include <math.h> 6 #include <assert.h> 7 #include <ctype.h> ...
高精度模板
编程资料大全
06-10 76
&lt;&lt;高精度模板&gt;&gt; #include &lt;cstdio&gt; #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;ctime&gt; #include &lt;cstring&gt; using namespace std; #define maxsize 1005 //建立一个结构体
高精度板子
玫葵之蝶
09-19 908
给大家分享一个好用的高精板子。#include<string> #include<iostream> #include<iosfwd> #include<cmath> #include<cstring> #include<stdlib.h> #include<stdio.h> #include<cstring> #define MAX_L 2005 //????,???? using namespa
基于时间互补性的强化学习方法对图像-视频人物再识别的研究
7319基于时间互补性的强化学习的图像-视频人物再识别Wei Wu<$，Jiawei Liu<$，Kecheng Zheng，Qibin Sun，Zheng-Jun Zha*中国科学技术大学{wuvy，zkcys001} @ mail.ustc.edu.cn，{jwliu6，qibinsun，zhazj} @ustc....
SD-Pose：6D对象姿态估计中的结构离散感知
1SD-Pose：结构离散感知类别级6D对象姿态估计Guowei Li1，2，Dongchen Zhu1，2，Guanghui Zhang1，Wenjun Shi1，Tanyu Zhang1，2，XiaolinZhang1，2，3，4，5，and Jiamao Li1，2，3 *1中国科学院上海微系统与信息...
对比模板预测的自监督视觉表征学习在非约束的数据集中展现出强大性能的研究
10160基于对比模板预测的自监督视觉表征学习赵玉成*†1王光庭*†1罗冲2曾文军2查正军‡1中国科学技术大学1微软亚洲研究院{lnc，flylight} @ mail.ustc.edu.cn{ cluo，wezeng} @ microsoft.comzhazj@ustc.edu.cn摘要...
稀疏变换器用于提高视觉跟踪性能的方法
+v：mala2277获取更多论文SparseTT：使用稀疏变换器的傅志红，傅泽华，刘庆杰，蔡文瑞，王云红北京航空航天大学虚拟现实技术与系统国家重点实验室北京航空航天大学杭州创新研究院{傅志红傅泽华刘庆杰蔡文瑞王毅}@ ...
高精度模板汇总
eternal风度
09-18 1206
高精度模板汇总 标签: 算法——高精度 高精加高精 很简单,直接做就行了 string S; struct GJ{ int s[N],L; void Print() { for(int i=L;i&gt;1;--i) printf("%d",s[i]); printf("%d\...
高精度模板（加，减，乘，除）
最新发布
2302_81019764的博客
04-24 518
高精度加法想象一下小学学的加法个位加个位。
高精度(模板)
qq_44754132的博客
03-01 298
处理大数运算的时候都是用字符串存的，高级语言一般也都有大数类，分装成一个对象，实际上就是维护了一个字符串，运算就是两个字符串之间的操作，他的运算也有很多啊，毕竟数学运算就有很多，简单的有 大数加大数 大数减大数 大数乘小数 大数除小数 上述几种都是最常见也是最简单的，运算的代码只有几行，而且都是模拟字符串的方法实现。 实际上大小数可以统一起来，就像能用INT的地方用LONG LONG 必然是可...
Clarke-Jakes-Zheng模型与瑞丽信道的matlab仿真分析
资源摘要信息:"Clarke_Jakes_Zheng模型matlab仿真_瑞丽信道仿真_" 知识点详细说明： 1. 瑞丽信道（Rayleigh Channel）仿真： 瑞丽信道是无线通信中的一种信道模型，用以描述在没有直接视距传播路径时，信号传输的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

A_zjzj

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值