「学习笔记」C++ 高精度算法

最新推荐文章于 2024-09-05 15:06:24 发布
最新推荐文章于 2024-09-05 15:06:24 发布
阅读量1.8w 收藏 167
点赞数 38
文章标签： 高精度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Binary_Heap/article/details/77823325
版权

高精度算法解决long long也解决不了的计算

 

高精度的存储是把每一位单独存储，且是倒序存储，数组num[1]是这个数的个位，num[2]是这个数的十位，以此类推;

 

 

（一）高精度加法

 

#include <iostream>
#include <cstring>
using namespace std;

struct HugeInt{
	int len;
	int num[100001];
}; 

HugeInt a, b, w;        //w为结果 
char c[100001], d[100001];

void Scan_HugeInt() {   //读入两个大整数 
	cin >> c;
	cin >> d;
	a.len = strlen(c); //strlen求串长 
	b.len = strlen(d);
	for(int i=0; i<a.len; i++) a.num[a.len - i] = c[i] - '0'; //逆序存储 
	for(int i=0; i<b.len; i++) b.num[b.len - i] = d[i] - '0';
}

void Plus() {
	w.len = max(a.len, b.len);           //num每一位是0，长度取max不影响加法 
	for(int i=1; i<=w.len; i++) {
		w.num[i] += a.num[i] + b.num[i]; 
		w.num[i+1] += w.num[i] / 10;    //处理进位
		w.num[i] %= 10;                 //处理当前位 保证<10 
	}
	if(w.num[w.len + 1] != 0) w.len ++;  //加法最多有可能会多出一位 
}

int main() {
	Scan_HugeInt();
	Plus();
	for(int i=w.len; i>=1; i--) cout << w.num[i]; //倒序存储 倒序输出 
	cout << endl;
	return 0;
}

 

 

 

（二）高精度减法

 

#include <iostream>
#include <cstring>
using namespace std;

struct HugeInt {
	int len;
	int num[100001];
};

HugeInt a, b, w;         //w为结果
char c[100001], d[100001];
bool negative;           //负数标记 

void Scan_HugeInt() {    //读入两个大整数
	cin >> c;
	cin >> d;
	if((strlen(c) < strlen(d)) || (strlen(c) == strlen(d) && strcmp(c, d) < 0)) { //若被减数小 交换 记为负数 
		negative = true;
		swap(c, d);
	}
	a.len = strlen(c);
	b.len = strlen(d);
	for(int i=0; i<a.len; i++) a.num[a.len - i] = c[i] - '0'; 
	for(int i=0; i<b.len; i++) b.num[b.len - i] = d[i] - '0';
}

void Minus() {
	w.len = a.len;                //a更大 
	for(int i=1; i<=w.len; i++) {
		if(a.num[i] < b.num[i]) {  
			a.num[i+1] --;      //num[i+1]减成负数也不影响 
			a.num[i] += 10;     //借位 
		}
		w.num[i] += a.num[i] - b.num[i];
	}
	while(w.num[w.len] == 0 && (w.len != 1)) w.len --; //多余的不是个位的0去掉 
}

int main() {
	Scan_HugeInt();
	Minus();
	if(negative == true) cout << "-";             //负数加负号 
	for(int i=w.len; i>=1; i--) cout << w.num[i]; //倒序存储 倒序输出
	cout << endl;
	return 0;
}

 

 

 

 

 

（三）高精度乘法

 

#include <iostream>
#include <cstring>
using namespace std;

struct HugeInt {
	int len;
	int num[100001];
};

HugeInt a, b, w; 
char c[10001], d[10001];

void Scan_HugeInt() {    //读入两个大整数
	cin >> c;
	cin >> d;
	a.len = strlen(c);
	b.len = strlen(d);
	for(int i=0; i<a.len; i++) a.num[a.len - i] = c[i] - '0';
	for(int i=0; i<b.len; i++) b.num[b.len - i] = d[i] - '0';
}

void Multiply() {
	int x;              //处理每次进位的变量 
	for(int i=1; i<=a.len; i++) {      //a的第i位 
		x = 0;
		for(int j=1; j<=b.len; j++) { //b的第j位 
			w.num[i+j-1] += a.num[i] * b.num[j] + x; //用 +=:结果与上次乘的结果相加 
			x = w.num[i+j-1] / 10;
			w.num[i+j-1] %= 10;          //进位处理 
		} 
		w.num[i+b.len] = x;  //多出的最高位 
	}
	w.len = a.len + b.len;
	while(w.num[w.len] == 0 && (w.len != 1)) w.len --; //多余的0 
}

int main() {
	Scan_HugeInt();
	Multiply();
	for(int i=w.len; i>=1; i--) cout << w.num[i];
	cout << endl;
	return 0;
}

 

（四）高精度除法

除以高精时，直接枚举每一位.

除以低精时，可以使用另种模拟更快


Int1000 operator / (const int &b) { //除以低精
	if(*this < Int1000(b)) return Int1000(0);
	Int1000 ans;
	ans.len = len;
	int r = 0;
	for(int i=ans.len; i>=1; i--) {
		r = r * 10 + a[i];
		ans.a[i] = r / b;
		r %= b;
	}
	while(ans.len > 1 && !ans.a[ans.len]) ans.len --;
	return ans;
}
Int1000 operator / (Int1000 b) {
	if(*this < b) return Int1000(0);
	Int1000 ans; ans.len = len - b.len + 1;
	for(int i=ans.len; i>=1; i--) {
		for(int j=1; j<=9; j++) {
			ans.a[i] ++;
			if((*this) < (ans * b)) {
				ans.a[i] --;
				break;
			}
		}
	        if(ans.a[ans.len] == 0) ans.len --;
        }
	while(ans.len > 1 && !ans.a[ans.len]) ans.len --;
	return ans;
}

 

高精度模版：

PS：常数较大，谨慎使用

 

const int MAX_SIZE = 1010;

struct Int {
	int len, n[MAX_SIZE];
	void Set(int l) {
		len = l;
		for(int i = 1; i <= len; i ++) n[i] = 0;
	}
	Int(char *s) {
		len = strlen(s);
		for(int i = len - 1; ~i; i --) {
			if(s[i] <= '9' && s[i] >= '0') {
				len = i + 1;
				break;
			}
		}
		for(int i = len; i >= 1; i --) n[i] = s[len - i] - '0';
	}
	Int(long long x = 0) {
		len = 0;
		do {
			n[++ len] = x % 10;
			x /= 10;
		} while(x);
	}
	bool operator < (const Int b) {
		if(len != b.len) return len < b.len;
		for(int i = len; i; i --)
			if(n[i] != b.n[i]) return n[i] < b.n[i];
		return false;
	}
	Int operator + (const Int b) const {
		Int ans; ans.Set(max(len, b.len) + 1);
		for(int i = 1; i <= ans.len; i ++) {
			if(i <= len) ans.n[i] += n[i];
			if(i <= b.len) ans.n[i] += b.n[i];
			ans.n[i + 1] += ans.n[i] / 10;
			ans.n[i] %= 10;
		}
		while(!ans.n[ans.len] && ans.len > 1) ans.len --;
		return ans;
	}
	Int operator - (const Int b) {
		Int ans, a = *(this); ans.Set(len);
		for(int i = 1; i <= ans.len; i ++) {
			if(a.n[i] < b.n[i]) a.n[i + 1] --, a.n[i] += 10;
			ans.n[i] += a.n[i] - (i > b.len ? 0 : b.n[i]);
		}
		while(!ans.n[ans.len] && ans.len > 1) ans.len --;
		return ans;
	}
	Int operator * (Int b) {
		Int ans; ans.Set(len + b.len);
		for(int i = 1; i <= len; i ++) {
			for(int j = 1; j <= b.len; j ++) {
				ans.n[i + j - 1] += n[i] * b.n[j];
				ans.n[i + j] += ans.n[i + j - 1] / 10;
				ans.n[i + j - 1] %= 10;
			}
		}
		while(!ans.n[ans.len] && ans.len > 1) ans.len --;
		return ans;
	}
	Int operator / (const int &b) { //除以低精  
     	    if(*this < Int(b)) return Int(0LL);  
     	    Int ans; ans.len = len;  
     	    int r = 0;  
     	    for(int i = ans.len; i; i --) {  
     		r = r * 10 + n[i];  
     		ans.n[i] = r / b;  
          	r %= b;  
        }  
            while(ans.len > 1 && !ans.a[ans.len]) ans.len --;  
            return ans;  
        }  
	Int operator / (const Int b) {
		if((*this) < b) return Int(0LL);
		Int ans; ans.Set(len - b.len + 1);
		for(int i = ans.len; i; i --) {
			for(int j = 1; j <= 9; j ++) {
				ans.n[i] ++;
				if((*this) < (ans * b)) {
					ans.n[i] --;
					break;
				}
			}
		}
		while(ans.len > 1 && !ans.n[ans.len]) ans.len --;
		return ans;
	}
	void print() {
		for(int i = len; i; i --) 
			printf("%d", n[i]);
		printf("\n");
	}
};

 

黑科技：两个long long实现高精度

typedef long long LL;
const LL Base = (LL)1e9;

struct Long {
    LL high, low;
    Long(LL x = 0) : low(x) {high = 0;}
    friend Long operator + (const Long &a, const Long &b) {
        Long c; c.high = a.high + b.high, c.low = a.low + b.low;
        if (c.high >= 0 && c.low >= Base) c.high += c.low / Base, c.low = c.low % Base;
        if (c.high <= 0 && c.low <= -Base) c.high += c.low / Base, c.low = c.low % Base;
        if (c.high > 0 && c.low < 0) c.high --, c.low += Base;
        if (c.high < 0 && c.low >= Base) c.high ++, c.low -= Base;
        return c;
    }
    friend bool operator <(const Long &a, const Long &b) {
        return a.high == b.high ? a.low < b.low : a.high < b.high;
    }
    friend Long max(const Long &a, const Long &b) {return a < b ? b : a;}
};

 

_Gion
关注
【有营养的算法笔记】基础算法 —— 高精度算法(加减乘除)
StackFrame
01-07 1720
四则高精度算法(加减乘除)的思路及模板、算法实现
C++学习笔记（1）——高精度算法（加法）
橙羊的博客
08-13 435
其中我们最常用的因该是int和long long，数据范围为-2^31~2^31-1和-2^63~2^63-1，最大的unsigned long long是0~2^64-1。但这是就有个问题了，有时候我们要计算两个整数之间的运算，那万一都是11位以上的“庞然大物”呢？a，b来存储加数，c存结果，那 么c[1]=a[1]+b[1],c[2]=a[2]+b[2],……我们来过一下：首先8+5=13，写3，进1。从这篇博客开始，我就要和大家分享我在学习C++过程中的一些干货，帮助大家更好的学习C++。...
C++算法之高精度计算
m0_72674633的博客
12-14 3409
算法竞赛从入门到精通
C++ 整数高精度加减乘除四则运算 算法
最新发布
qq_62111349的博客
09-05 967
这里的除法包括高精度除以低精度和高精度除以高精度哦~这些写法可能不是最优的，但是至少比较好懂（毕竟我这个小白都懂了）。并且这里要求输入的数都是正常的整数形式，比如，不能是000114514而是114514.
C++ 算法 高精度（较详细.）
热门推荐
Wiki_H的博客
01-25 2万+
概念 在我们进行计算的过程中，经常会遇到几十位，甚至几百位的数字的计算问题，也有可能会遇到小数点后几十位，几百位的情况，而我们面对这样的情况下， 和 的数据范围显然是不够使用的了。因此这时，我们就需要引入一个新的算法，叫做高精度算法 . 我们可以利用程序设计的方法去实现这样的高精度计算 . 介绍常用的几种高精度计算的方法 . 思想 高精度算法本质上是用字符串模拟数字进行计算，再利用类似于数学里的竖式的形式，一位一位进行相关计算 ....
高精度算法（c++）
2301_81587174的博客
08-09 1154
在C++中，高精度和低精度通常指的是处理数字时所用的数据结构的精度高低。例如，如果你使用内置的整型（如intlong或long long）来处理较大的数字，它们可能会溢出，这时你可能会使用数组或者来模拟大整数，这样的结构就可以看作是高精度数据类型。而对应地，低精度可以理解为使用较小的数据类型，如charshort或内置的整数类型。C++标准规定：int占一个机器字长，在32位系统中int占32位，即4个字节，所以int的范围是[-,],为数量级。long long的范围则是[,],为数量级。
C++算法(高精度算法)
博客
05-01 3790
C++高精度算法
C++高精度算法
一个平平无奇的博客，一个平平无奇的人，一个平平无奇的约定
10-04 7271
C++高精度加、减、乘、除 大家可以直接拿走，欢迎转载
C++ 高精度算法（并附实例）
WIND_NAN的博客
07-26 6114
C++ 高精度算法（并附实例）
算法笔记（四）：高精度
Cooperia的博客
07-17 1586
（3）高精度算法 目录 1、高精度算法 高精度算法介绍 高精度与竖式计算 进位和前导零 2、高精度数的加减乘除 高精度加法 高精度减法 高精度乘法 高精度除法 写在最后！！！ 1、高精度算法 高精度算法介绍 高精度算法（High Accuracy Algorithm）是处理大数字的一种数学计算方法，是用计算机对于超大数字的一种模拟加减乘除等的运算。但是计算机无法正常存储非常庞大的数字，便把数字进行拆分存储到一个数组找那个，用一个数组去表示一个数字，这样的数字便是高精度数。简言.
大一新生算法学习笔记：高精度到动态规划
在高精度加法部分，代码示例使用C++实现，通过将输入的字符串转换为整数数组，然后逐位相加处理进位。高精度减法、乘法和除法也遵循类似思路，但涉及更复杂的逻辑，如负数处理和除法的迭代求解。 接着，文档详细...
c++高精度（支持高精度除单精度）
02-14
第二版已全面提升性能，并修复了一个严重的内存泄漏的bug。欢迎下载使用！
算法学习笔记.pdf
06-22
高精度算法、前缀和算法、差分算法等都与二分搜索有紧密联系，它们通常用于解决一些数值问题或优化搜索过程。 五、双指针算法 双指针算法在处理有序数组或链表中非常有用，它可以通过两个指针在数组或链表上移动来...
高精度算法（加、减、乘、除，使用c++实现）
x3262551980的博客
04-02 3886
在我们进行计算的过程中，经常会遇到的计算问题，也有可能会遇到小数点后几十位，几百位的情况，而我们面对这样的情况下，和的数据范围显然是不够使用的了。因此这时，我们就需要引入一个新的算法，叫做高精度算法：它是处理大数字的数学计算方法，在一般的科学计算中，会经常算到小数点后几百位或者更多，当然也可能是几千亿几百亿的大数字。一般这类数字我们统称为高精度数，高精度算法是用计算机对于超大数据的一种模拟加，减，乘，除等运算。思想：高精度算法本质上是用模拟数字进行计算，再利用类似于数学里的，一位一位进行相关计算。
C++ 高精度算法
weixin_61949600的博客
03-30 1105
做题笔记1：洛谷_高精度
高精度算法C++
LXCliuxingchen的博客
07-23 844
要处理高精度大整数加低精度整数的运算，我们可以使用string来存储大整数，然后通过模拟我们小学时学到的逐位相加和进位的过程来实现加法。在进行高精度大整数与低精度整数的加法运算时，可以采用以下步骤：将高精度大整数和小整数转换为相同格式的数据，以便进行加法运算。通常，这可以通过将小整数扩展到与大整数相同的位数来实现。使用适合高精度运算的方法来进行加法。例如，可以将每个数字分解为它的各个位数，然后对这些位数进行加法，同时处理进位。在加法过程中，需要注意对齐两个数字的位数，以确保正确相加。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值