填坑行动1-高精度运算

最新推荐文章于 2022-05-30 21:28:22 发布
最新推荐文章于 2022-05-30 21:28:22 发布
阅读量150 收藏
点赞数
分类专栏： 笔记 填坑行动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangtaizhe/article/details/107935774
版权

文章目录


拖更很久了

Update8.12:更改了一些错误的地方

前置芝士-运算符重载

例子

看下边的代码：

#inclue<iostream>
using namespace std;
int main(){
	int a,b;
	cin>>a>>b;
	cout<<a+b;
}

cin>>a>>b在这里是指输入两个数 a , b a,b a,b，就有人会问了，>>不是右移吗？怎么用来输入变量了？其实这就是一个简单的运算符重载。

方法

那么我们改怎么重载呢？

类型 operator 符号(参数) const {
	内容（记得带返回值）
}

其中const是要在结构体里面定义的时候才加。
可以重载的符号有：

new delete new[] delete[]
+ - * / % ^ & & | ~
! = < > += -=  *= /= %=
^= &= |= << >> >>= <<=
== != <= >=  &&  || ++
-- , ->* -> () []

其中[]指下标，
可以有两个参数，也可以有一个参数的有：

+ - * &

当然，重载流输流输出有不一样的格式，这是友元函数：

friend istream & operator >> (istream &,bigint &x){
	...
	return cin;
}
friend ostream & operator <<(ostream &,bigint x){
	...
	return cout;
}

高精度运算

存储

有些时候进行运算的时候，数字会很大，导致int_128都装不下，不如自己动手，丰衣足食，自己定义一种变量，满足进行很大的数字的运算。这里叫bigint
那么，bigint里面要有什么东西呢？我们先看一下short是怎么存贮的：主要是int有32位画不下
在这里插入图片描述
我们就可以定义一个数组，数组的每一位，代表每一个数。还有两个变量，一个代表长度，一个代表正负，就是这样：

struct bigint{
	int len,flag;//flag 1 fu 0 zheng 
	int a[maxn];
}
输入输出&&运算原理

然后考虑怎么运算，其实很简单，就像小学生一样做竖式运算就可以了，为了方便进行运算，令 a 1 a_1 a1​为个位， a 2 a_2 a2​为十位， a 3 a_3 a3​为百位，以此类推即可。
然后考虑怎么输入，我们发现，输入的是一个很大的数字，不能直接用cin，为了一次性读入，我们读入一个字符串 s s s，不难得到 a i = s l e n − i a_i=s_{len-i} ai​=slen−i​，最后删去前导零，比如说 0001 0001 0001要写成 1 1 1
输出只要倒着输出就可以了。一个for循环搞定。记得注意符号。
奉上输入输出重载：

	friend istream & operator >> (istream &,bigint &x){
		char s[maxn]; cin>>s;
		x.len=strlen(s);
		if(s[0]=='-') x.flag=1;
		memset(x.a,0,sizeof(x.a));
		if(x.flag)
		    for(register int i=1;i<x.len;i++) 
	            x.a[i]=s[x.len-i]^48;
	    else for(register int i=1;i<=x.len;i++) 
	            x.a[i]=s[x.len-i]^48;
	    for(;x.len>1;x.len--)
	        if(x.a[x.len]!=0)
	        	break;//删去前导零 
	    return cin;
	}
	friend ostream & operator <<(ostream & ,bigint x){
		if(x.flag) printf("-");
		int flag=0;
		for(register int i=x.len;i>=1;i--){
			if(x.a[i]>0) flag=1;
			if(flag)
		    	printf("%d",x.a[i]);
		}
		if(!flag) putchar('0');
		return cout;
	}
加减

加减只要按照竖式法从低到高加就可以了，还要注意进位，算法复杂度 Θ ( n ) \Theta(n) Θ(n)
注意正负就可以了。（初中老师应该讲过有理数的加减的吧）

乘除

乘法依旧是竖式计算，不过正负的处理更加简单。
注意 a i × b j a_i\times b_j ai​×bj​的结果应该储存在 a n s i + j − ‘ ans_{i+j-`} ansi+j−‘​中，注意ans.len=a.len+b.len-1或者ans.len=a.len+b.len
除法也可以用竖式解决，这里暂时不涉及。

代码

最后献上代码。据说很多人喜欢这个

struct bigint{
	int len,flag;//flag 1 fu 0 zheng 
	int a[maxn];
	bigint (*intit)(int);
	void (*check)(bigint);
	friend istream & operator >> (istream &,bigint &x){
		char s[maxn]; cin>>s;
		x.len=strlen(s);
		if(s[0]=='-') x.flag=1;
		memset(x.a,0,sizeof(x.a));
		if(x.flag)
		    for(register int i=1;i<x.len;i++) 
	            x.a[i]=s[x.len-i]^48;
	    else for(register int i=1;i<=x.len;i++) 
	            x.a[i]=s[x.len-i]^48;
	    for(;x.len>1;x.len--)
	        if(x.a[x.len]!=0)
	        	break;//ɾȥǰµ¼Áã 
	    return cin;
	}
	friend ostream & operator <<(ostream & ,bigint x){
		if(x.flag) printf("-");
		int flag=0;
		for(register int i=x.len;i>=1;i--){
			if(x.a[i]>0) flag=1;
			if(flag)
		    	printf("%d",x.a[i]);
		}
		if(!flag) putchar('0');
		return cout;
	}
	bool operator > (const bigint &x)const{
		if(!x.flag&&!this->flag){
			if(this->len > x.len ) return true;
			if(this->len < x.len ) return false;
			for(int i=x.len;i>=1;i--)
			    if( this->a[i] > x.a[i] ) return true;
			    else if( this->a[i] < x.a[i] ) return false;
		}
		if(this->flag&&!x.flag) return false;
		if(!this->flag&&x.flag) return true;
		
		if(this->len < x.len ) return true;
		if(this->len > x.len ) return false;
		for(int i=x.len;i>=1;i--)
		    if( this->a[i] < x.a[i] ) return true;
			else if( this->a[i] > x.a[i] ) return false;
		return false;
	}
	bool operator == (const bigint &x)const{
		if(x.flag!=this->flag) return 0;
		for(int i=1;i<=max(x.len,this->len);i++)
		    if(x.a[i]!=this->a[i])
		        return 0;
		return 1;
	}
	bool operator < (const bigint &x) const { return !(*this>=x); }
	bool operator <= (const bigint &x) const { return !(*this>x); }
	bool operator >= (const bigint &x) const { return *this>x || *this==x;}
	bigint operator +(const bigint &x) const {
		bigint ans=(bigint){0,0,{}};
		int jw=0;
		if(this->flag==x.flag){
			ans.flag=x.flag;
			ans.len=max(this->len,x.len);
			for(int i=1;i<=ans.len;i++)
			    if(this->a[i]+x.a[i]+jw>=10){
			    	ans.a[i]=(this->a[i]+x.a[i]+jw)-10;
			    	jw=1;
				}
				else{
					ans.a[i]=(this->a[i]+x.a[i]+jw);
			    	jw=0;
				}
			if(jw==1){ ans.len++; ans.a[ans.len]=1; }
			return ans;
		}
		bigint thi;
		int flag,tw;
		if(this->flag==1&&x.flag==0){
			memset(thi.a,0,sizeof(thi.a));
		    for(int i=1;i<=x.len;i++)
				thi.a[i]=this->a[i];
			thi.flag=0;
			thi.len=this->len;
			if(thi>x){
				ans.flag=1;
				for(int i=1;i<=thi.len;i++)
					if(thi.a[i]-tw-x.a[i]<0){
						ans.a[i]=thi.a[i]-tw-x.a[i]+10;
						tw=1;
					}
					else{
						ans.a[i]=thi.a[i]-tw-x.a[i];
						tw=0;
					}
				ans.len=thi.len;
			}
			else{
				ans.flag=0;
				for(int i=1;i<=x.len;i++)
					if(x.a[i]-tw-thi.a[i]<0){
						ans.a[i]=x.a[i]-tw-thi.a[i]+10;
						tw=1;
					}
					else{
						ans.a[i]=x.a[i]-tw-thi.a[i];
						tw=0;
					}
				ans.len=x.len;
			}
		}
		if(this->flag==0&&x.flag==1){
			memset(thi.a,0,sizeof(thi));
			for(int i=1;i<=x.len;i++)
				thi.a[i]=x.a[i];
			thi.flag=0; thi.len=x.len;
			if(*this>=thi){
				ans.flag=0; ans.len=this->len;
				for(int i=1;i<=ans.len;i++)
					if(this->a[i]-tw-thi.a[i]<0){
						ans.a[i]=this->a[i]-tw-thi.a[i]+10;
						tw=1;
					}
					else{
						ans.a[i]=this->a[i]-tw-thi.a[i];
						tw=0;
					}
			}
			else{
				ans.flag=1; ans.len=thi.len;
				for(int i=1;i<=ans.len;i++)
					if(thi.a[i]-tw-this->a[i]<0){
						ans.a[i]=thi.a[i]-tw-this->a[i]+10;
						tw=1;
					}
					else{
						ans.a[i]=thi.a[i]-tw-this->a[i];
						tw=0;
					}
			}
		}
		while(ans.len>1&&ans.a[ans.len]==1) ans.len--;
		return ans;
	}
	bigint  operator -(const bigint &x) const {
		bigint thi;
		memset(thi.a,0,sizeof(thi.a));
		thi.len=x.len;
		for(int i=1;i<=x.len;i++)
			thi.a[i]=x.a[i];
		thi.flag=!x.flag;
		return *this+thi;
	}
	bigint operator *(bigint &x){
		bigint ans=(bigint){0,0,{0}};
		for(register int i=1;i<=x.len;i++)
		    for(register int j=1;j<=this->len;j++){
		    	ans.a[i+j-1]+=this->a[j]*x.a[i];
		    	ans.a[i+j]+=ans.a[i+j-1]/10;
		    	ans.a[i+j-1]%=10;
			}
		ans.len=this->len+x.len+1;
		ans.flag=(this->flag)^(x.flag);
		while(ans.a[ans.len]==0&&ans.len>1) ans.len--;
		return ans;
	}
};
bigint intit(int x){
	bigint ans=(bigint){0,0,{0}};
	if(x<0){
		x=-x;
		ans.flag=1;
	}
	if(x==0){
		ans.len=1;
		return ans;
	}
	while(x>0){
		ans.a[++ans.len]=x%10;
		x/=10;
	}
	return ans;
}

记得定义maxn的大小哦~~~（maxn是位数）
这里重载了 >> << + - * > < >= <= ==
bigint init(int)是把一个int类型的数转化成bigint类型。
完结撒花

jiangtaizhe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Qt开发经验总结
草上爬的博客
12-02 8133
增加了很多轮子，同时原有模块拆分的也更细致，估计为了方便拓展个管理。把一些过度封装的东西移除了（比如同样的功能有多个函数），保证了只有一个函数执行该功能。把一些Qt5中兼容Qt4的方法废弃了，必须用Qt5中对应的新的函数。跟随时代脚步，增加了不少新特性以满足日益增长的客户需求。对某些模块和类型及处理进行了革命性的重写，运行效率提高不少。有参数类型的变化，比如 long * 到 qintptr * 等，更加适应后续的拓展以及同时对32 64位不同系统的兼容。
高精度计算——数据的接受方法和存储方法
Flora_SM的博客
01-30 543
1.当输入的数很长时，可采用字符串方式输入，利用字符串函数和操作运算，将每一位数取出，存入数组中。  void  init(int a[ ])                     //传入一个数组；     {        string s; int l;         cin>>s;       l=s.length();                      //也可以a
待填坑--浮点算法和除法运算
qq_18268761的博客
11-06 465
1.定点数 定点小数的加减法和整数的相同，并且和小数点的位置无关。乘法就不同了。 1.2*3.4=4.08。这里1.2的小数点在第1位之前，而4.08的小数点在第2位之前，小数点发生了移动。所以在做乘法的如果小数点位数不同就舍弃最低位。 也就说1.2*3.4=4.1，这样我们就得到正确的定点运算的结果了。所以在做定点小数运算的时候不仅需要牢记小数点的位置，还需要记住表达定点小数的...
java基础语法--面向过程
qq_48319619的博客
04-12 471
Java基础，面向过程
蓝桥杯2013-2016真题
doyoudooo的博客
05-04 1851
13-16年真题
2021-09-02
shade7的博客
11-12 2117
1.go中goroutine是如何调度的（go MPG模型） M代表一个内核线程，也可以称为一个工作线程。goroutine就是跑在M之上的。（两个M如果运行在一个CPU上就是并发，如果运行在不同CPU就是并行。） P 代表着处理器，或是程序执行上下文，将等待执行的G与M对接。Go的运行时系统会适时地让P与不同的M建立或断开关联，以使P中的那些可运行的G能够及时获得运行时机； G代表协程（是一个轻量级的执行线程），可以有多个； （go采用了基于消息并发模型的方式。它将基于CSP模型的并发编程内置到了
java面试.1
qq_27208063的博客
05-15 3444
关注公众号『Java专栏』,发送『面试』 获取该项目完整PDF [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WM1UgjaX-1589530428920)(qr_code.jpg)] 基础篇 1、 Java语言有哪些特点 2、面向对象和面向过程的区别 3 、八种基本数据类型的大小，以及他们的封装类 4、标识符的命名规则。 5、instanceof 关键字的作用 6、Java自动装箱与拆箱 7、 重载和重写的区别 8、 equals与==的区别 9、 Hashcode
全日制英国硕士词汇篇V1.3（持续更新）
热门推荐
欢迎！欢迎来到17号城市！
03-05 6万+
下面的所有词汇与例句都是在英国留学期间， 学到的、听到的、见到的，都来自英语母语使用者，其中包括： 学校、同学、教授、教职人员、以及生活中形形色色的人， 这篇文章有助于还没去英国的同学提前掌握一些高频词汇， 以便于在日后的留学生活中更加游刃有余， 对于高频词汇一定要掌握它们的听说读写，形成肌肉记忆。
岩土工程英语词汇A-R
竹子的专栏
11-09 2万+
转至http://blog.sina.com.cn/s/blog_448e99520100o9l0.html A abrasion action 磨蚀作用 abrasives 研磨料；研磨物 absolute age 绝对年龄 absorbed layer 吸附层 absorbed water 吸(附)水 absorption limit 吸附界限 absorption l
高精度计算--高精度加法详解
qq_40790042的博客
08-22 9654
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、高精度加法分析1.1 数学的竖式加法计算1.2 数组模拟竖式计算1.3 计算步骤分析二、使用步骤2.1 代码结构2.2 读入数据并倒置：readDataAndReverse(int *arr,int &len)函数2.3 两个数据相加：addData(int *a,
C++高精度运算
PanDaoxi
05-30 1875
C++高精度运算
【第50题】常用的数学工具类7-高精度浮点运算
小虚竹的专栏
05-03 2万+
数学工具类
【第49题】常用的数学工具类6-高精度整数运算
小虚竹的专栏
05-03 2万+
数学工具类
高精度运算
weixin_54375830的博客
01-13 3695
int a ;//数据类型的范围：-2^31~2^31-1,数量级为10^9 long long int ;//数据类型范围：-2^63~2^63-1,数量级为10^18 //由于进行较大的数运算时，无法用Int 和long long 所以下面需要学习高精度 一.高精度的加法 //算法核心； c[i]+=a[i]+b[i]; c[i+1]=c[i]/10; c[i]=c[i]%10; 加法完整代码： //代码 #include<iostream> using namespa.
填坑行动7-树的直径及求出树的直径路径
jiangtaizhe的博客
07-17 617
文章目录树的直径的定义求出树的直径的长度 树的直径的定义 树的直径是树里面最长的一条链。树的直径不仅仅只有一条。 求树的直径有两种方法：搜索和树形DP。这里主要介绍树形DP。 求出树的直径的长度 ...
链式前向星 学习笔记
jiangtaizhe的博客
02-07 401
文章目录板子题-图的dfs题目描述输入输出样例输入样例输出算法理解 板子题-图的dfs 题目描述 一个有n个节点的连通图，这些节点以编号：1,2,……n1,2,……n1,2,……n (1≤n,e≤10000001\leq n,e\leq 10000001≤n,e≤1000000)进行编号，现给出节点间的连接关系。请以节点1为起点，按dfs的顺序遍历并输出该图。 输入 第一行为两整数，nnn和eee...
轻重链剖分 学习笔记
jiangtaizhe的博客
08-22 400
文章目录板子题算法解析定义实现预处理修改复杂度代码 板子题 题目传送门 这道题目要求在树上修改和查询点一条链上或者是一棵子树的点的权值。 算法解析 考虑使用LCA，但是不能使用倍增的解法（倍增只能查询不能修改），所以我们要使用一种新的算法——轻重链剖分。 建议先学完LCA在来看这篇文章。 定义 这里列出一些必要的定义： 重儿子：子节点最多的一个儿子。 轻儿子：一个节点的儿子除重儿子之外的儿子。 重边：一段为重儿子的边。 轻边：除重边以外的边。 重链：由重边组成的链，由轻儿子为起点。 实现 预处理 预处理
博弈论入门
jiangtaizhe的博客
08-28 386
文章目录0x00-前(che)言(dan)0x01-Bash Game0x02 Nim Gmae0x03 Wythoff Game 0x00-前(che)言(dan) 不务正业系列 貌似是因为要交数学作业 博弈论在OI技能树上的标签是 提高/省选/NOI\color{#9D3DCF}\text{提高/省选/NOI}提高/省选/NOI 的，但是一些基础还是可能在初赛的问题求解考到的，（虽然主要考组合数学），但是早学晚学都得学 其实博弈论的精髓就在于一个转移迭代： 如果这种情况能有必胜策略，那么它一定能转移到一
高精度运算实现与优化策略
"本文主要介绍了高精度运算的原理和实现方法，包括数据类型的转换、高精度数的存储、加减乘除运算以及如何提高运算效率。文中提到了使用整数数组来表示大数，通过字符串读入并进行倒序存储。此外，还分析了不同运算...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值