基础算法--高精度

已于 2024-03-22 00:37:02 修改
阅读量360 收藏 9
点赞数 8
分类专栏： 基础算法 文章标签： c++ 算法
于 2024-02-06 18:09:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76144982/article/details/136060111
版权

高精度模板小总结( 字符串数组 || vector )

高精度加高精度：P1601 A+B Problem（高精）

#include<iostream>
#include<cstring>
using namespace std;
string A, B;
int a[10000], b[10000], sum[10000];
int main(){ 
	cin >> A >> B;
	int la = A.size(), lb = B.size();
	for (int i = 0; i < la; i++)
		a[i] = A[la - i - 1] - '0';
	for (int i = 0; i < lb; i++)
		b[i] = B[lb - i - 1] - '0';
	int jw = 0;
	for (int i = 0; i < (la > lb ? la : lb) + 1; i++) {
		sum[i] = a[i] + b[i] + jw;
		jw = sum[i] / 10;
		sum[i] %= 10;
	}
	int flag = 0;
	for (int i = (la > lb ? la : lb); i >= 0; i--) {
		if (sum[i] != 0)
			flag = 1;
		if (flag)
			cout << sum[i];
	}
	if (flag == 0)
		cout << "0";
	cout << endl;
	return 0;
}
#include<iostream>
#include<cstring>
using namespace std;
string A, B;
int a[10000], b[10000];
int la, lb;
void qiuhe(int* a) {
	int jw = 0;
	for (int i = 0; i < (la > lb ? la : lb) + 1; i++) {
		b[i] = a[i] + b[i] + jw;
		jw = b[i] / 10;
		b[i] %= 10;
	}
}
int main(){ 
	cin >> A >> B;
	la = A.size(), lb = B.size();
	for (int i = 0; i < la; i++)
		a[i] = A[la - i - 1] - '0';
	for (int i = 0; i < lb; i++)
		b[i] = B[lb - i - 1] - '0';
	qiuhe(a);
	int flag = 0;
	for (int i = (la > lb ? la : lb); i >= 0; i--) {
		if (b[i] != 0)
			flag = 1;
		if (flag)
			cout << b[i];
	}
	if (flag == 0)
		cout << "0";
	cout << endl;
	return 0;
}
#include<iostream>
#include<vector>
using namespace std;
string A, B;
vector<int>a, b, c;
vector<int>add(vector<int>& a, vector<int>& b) {
	int t = 0;
	for (int i = 0; i < a.size() || i < b.size(); i++) {
		if (i < a.size())
			t += a[i];
		if (i < b.size())
			t += b[i];
		c.push_back(t % 10);
		t /= 10;
	}
	if (t)
		c.push_back(1);
	return c;
}
int main() {
	cin >> A >> B;
	for (int i = A.size() - 1; i >= 0; i--)
		a.push_back(A[i] - '0');
	for (int i = B.size() - 1; i >= 0; i--)
		b.push_back(B[i] - '0');
	auto c = add(a, b);
	for (int i = c.size() - 1; i >= 0; i--)
		cout << c[i];
	return 0;
}

高精度减高精度：P2142 高精度减法

#include<iostream>
#include<cstring>
using namespace std;
string A, B;
int a[100000], b[100000],sub[100000];
int la, lb;
int main(){ 
	cin >> A >> B;
	la = A.size(), lb = B.size();
	int key = 0;
	if (la < lb) {
		cout << "-";
		key = 1;
	}
	else if (la == lb) {
		for (int j = la; j >= 0; j--) {
			if (a[j] < b[j]) {
				cout << "-";
				key = 1;
				break;
			}
			else if (a[j] == b[j])
				continue;
			else
				break;
		}
	}
	else {
		key = 0;
	}
	for (int i = 0; i < la; i++)
		a[i] = A[la - i - 1] - '0';
	for (int i = 0; i < lb; i++)
		b[i] = B[lb - i - 1] - '0';
	if (key) {
		for (int i = 0; i < lb; i++) {
			int x = b[i];
			b[i] = a[i];
			a[i] = x;
		}
	}
	for (int i = 0; i < (la > lb ? la : lb); i++) {
		if (a[i] < b[i]) {
			a[i + 1] -= 1;
			a[i] += 10;
		}
		sub[i] = a[i] - b[i];
	}
	int flag = 0;
	for (int i = (la > lb ? la : lb) - 1; i >= 0; i--) {
		if (sub[i] != 0)
			flag = 1;
		if (flag)
			cout << sub[i];
	}
	if (flag == 0)
		cout << "0";
	cout << endl;
	return 0;
}
#include<iostream>
#include<vector>
using namespace std;
string A, B;
vector<int>a, b, c;
bool cmp(vector<int>& a, vector<int>& b) {
	if (a.size() != b.size())
		return a.size() > b.size();
	else {
		for (int i = a.size() - 1; i >= 0; i--)
			if (a[i] != b[i])
				return a[i] > b[i];
	}
	return true;
}
vector<int>sub(vector<int>& a, vector<int>& b) {
	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;
}
int main() {
	cin >> A >> B;
	for (int i = A.size() - 1; i >= 0; i--) a.push_back(A[i] - '0');
	for (int i = B.size() - 1; i >= 0; i--) b.push_back(B[i] - '0');
	if (cmp(a, b)) {
		auto c = sub(a, b);
		for (int i = c.size() - 1; i >= 0; i--)
			cout << c[i];
	}
	else {
		auto c = sub(b, a);
		cout << "-";
		for (int i = c.size() - 1; i >= 0; i--)
			cout << c[i];
	}
	return 0;
}

高精度乘低精度

#include<iostream>
#include<cstring>
using namespace std;
string A;
int a[10000], b, la;
void chengfa(int* a, int x) {
     int jw = 0;
	 for (int i = 0; i < 10000; i++) {
         long long s = a[i] * x + jw;
         jw = s / 10;
         a[i] = s % 10;
     }
}
int main(){ 
	cin >> A >> b;
	int la = A.size();
	for (int i = 0; i < la; i++)
		a[i] = A[la - i - 1] - '0';
	chengfa(a, b);
	int flag = 0;
	for (int i = 9999; i >= 0; i--) {
		if (a[i] != 0)
			flag = 1;
		if (flag)
			cout << a[i];
	}
	if (flag == 0)
		cout << "0";
	cout << endl;
	return 0;
}

#include<iostream>
#include<vector>
using namespace std;
string A; int b;
vector<int>a, c;
vector<int>mul(vector<int>& a,int b){
	int 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;
	}
	while (c.size() > 1 && c.back() == 0)
		c.pop_back();
	return c;
}
int main() {
	cin >> A >> b;
	for (int i = A.size() - 1; i >= 0; i--)
		a.push_back(A[i] - '0');
	auto c = mul(a, b);
	for (int i = c.size() - 1; i >= 0; i--)
		cout << c[i];
	return 0;
}

高精度乘高精度：P1303 A*B Problem

#include<iostream>
#include<cstring>
using namespace std;
string A, B;
int a[100000], b[100000],mul[100000];
int la, lb;
int main(){ 
	cin >> A >> B;
	la = A.size(), lb = B.size();
	for (int i = 0; i < la; i++)
		a[i] = A[la - i - 1] - '0';
	for (int i = 0; i < lb; i++)
		b[i] = B[lb - i - 1] - '0';
	for (int i = 0; i < la; i++)
		for (int j = 0; j < lb; j++)
			mul[i + j] += a[i] * b[j];
	for (int i = 0; i < la + lb; i++) {
		if (mul[i] > 9) {
			mul[i + 1] += mul[i] / 10;
			mul[i] %= 10;
		}
	}
	int flag = 0, i = 0;
	for (i = la + lb - 1; i >= 0; i--) {
		if (mul[i] != 0) {
			flag = 1;
			break;
		}
	}
	if (flag) {
		for (i; i >= 0; i--)
			cout << mul[i];
	}
	else
		cout << "0";
	cout << endl;
	return 0;
}
#include<iostream>
#include<vector>
using namespace std;
string A, B;
vector<int>a, b;
vector<int>mul(vector<int>& a, vector<int>& b) {
	vector<int>c(a.size() + b.size() + 5, 0);
	for (int i = 0; i < a.size(); i++)
		for (int j = 0; j < b.size(); j++)
			c[i + j] += a[i] * b[j];
	int t = 0;
	for (int i = 0; i < c.size(); i++) {
		t += c[i];
		c[i] = t % 10;
		t /= 10;
	}
	while (c.size() > 1 && c.back() == 0)
		c.pop_back();
	return c;
}
int main() {
	cin >> A >> B;
	for (int i = A.size() - 1; i >= 0; i--)
		a.push_back(A[i] - '0');
	for (int i = B.size() - 1; i >= 0; i--)
		b.push_back(B[i] - '0');
	auto c = mul(a, b);
	for (int i = c.size() - 1; i >= 0; i--)
		cout << c[i];
	return 0;
}

阶乘之和：P1009 [NOIP1998 普及组] 阶乘之和

#include<iostream>
using namespace std;
const int value = 1e5;
void jiecheng(int* a, int n) {
	a[0] = 1;
	for (int k = 1; k < value; k++)
		a[k] = 0;
	int i, j;
	for (i = 2; i <= n; i++) {
		int jw = 0;
		for (j = 0; j < value; j++) {
			int s = a[j] * i + jw;
			jw = s / 10;
			a[j] = s % 10;
		}
	}
}
int sum[value];
void qiuhe(int* a) {
	int jw = 0;
	for (int i = 0; i < value; i++) {
		sum[i] = sum[i] + a[i] + jw;
		jw = sum[i] / 10;
		sum[i] %= 10;
	}
}
int main() {
	int n, m;	cin >> n;
	int a[value] = { 0 };
	for (int i = 1; i <= n; i++) {
		jiecheng(a, i);
		qiuhe(a);
	}
	int i;
	for (i = value - 1; i >= 0; i--) {
		if (sum[i] == 0)
			continue;
		break;
	}
	for (i; i >= 0; i--)
		cout << sum[i];
	return 0;
}

高精度除低精度：P1480 A/b Problem

#include<iostream>
#include<cstring>
using namespace std;
string A;
int a[100000], divide[100000];
long long b, r;
int la;
int main(){ 
	cin >> A >> b;
	la = A.size();
	for (int i = 0; i < la; i++)
		a[i] = A[i] - '0';
	for (int i = 0; i < la; i++) {
		r = r * 10 + a[i];
		divide[i] = r / b;
		r %= b;
	}
	int flag = 0, i = 0;
	for (i ; i < la; i++) {
		if (divide[i] != 0) {
			flag = 1;
			break;
		}
	}
	if (flag) {
		for (i; i < la; i++)
			cout << divide[i];
	} 
	else
		cout << "0";
	cout << endl;
	return 0;
}
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
string A; int b, r;
vector<int>a, c;
vector<int>div(vector<int>& a, int b, int& r) {
	r = 0;
	for (int i = a.size() - 1; i >= 0; i--) {
		r = r * 10 + a[i];
		c.push_back(r / b);
		r %= b;
	}
	reverse(c.begin(), c.end());
	while (c.size() > 1 && c.back() == 0)
		c.pop_back();
	return c;
}
int main() {
	cin >> A >> b;
	for (int i = A.size() - 1; i >= 0; i--)
		a.push_back(A[i] - '0');
	auto c = div(a, b, r);
	for (int i = c.size() - 1; i >= 0; i--)
		cout << c[i];
	cout << endl << r << endl;
	return 0;
}
Cloud_Ivy37
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第二部分 基础算法 -> 第一章 高精度计算
12-09
算法-基础算法- 高精度计算- 高精度加法（包含源程序）.rar
09-16
算法-基础算法- 高精度计算- 高精度加法（包含源程序）.rar
算法-基础算法- 高精度计算（包含源程序）.rar
09-16
算法-基础算法- 高精度计算（包含源程序）.rar
基础算法-高精度计算(c/c++)|信息学奥赛、ACM、蓝桥杯
07-22
我们可以利用程序设计的方法去实现这样的高精度计算。介绍常用的几种高精度计算的方法。 适合人群：acm、蓝桥杯、信息学奥赛等算法竞赛 能学到：基本的高精度计算的方法 阅读建议：理解代码并进行实践
《信息学竞赛宝典-基础算法》视频讲解-第8章 高精度算法
03-15
《信息学竞赛宝典--基础算法》，人民邮电出版社 c++基础算法视频讲解---第8章 第8章 8.1.2高精度加法 8.1.6高精度数除以低精度数1 8.1.1被限制的加法 8.1.4高精度减法 8.1.5最大值减最小值 8.1.3蜜蜂线路 8.1.8高...
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 658
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
【C++风云录】打破边界：心理学与情绪识别
记录我的学习历程
05-16 710
本文主要探讨了六种开发软件工具包，包括但不限于面部表情分析、心理学实验设计、图像处理、数据挖掘、情绪识别以及生物识别技术等各类关键功能，同时也涵盖了其在各自领域的应用。
【C++】初始化列表
qq_46049113的博客
05-19 135
当创建一个类的实例时，类的构造函数会被调用来初始化该实例。构造函数可以通过其体（即大括号内的代码部分）或通过初始化列表来初始化成员变量。：使用初始化列表可以直接初始化成员变量，而不是先默认构造成员然后再赋值。：对于常量成员变量和引用成员，初始化列表是必需的，因为这些类型的成员一旦创建后就不能再被赋值。：如果一个类继承自基类，或者它包含其他类的对象作为成员，这些基类和成员对象只能通过初始化列表进行初始化。这种初始化方式确保了代码的效率和成员变量的正确设置，特别是在涉及复杂类型或类的资源管理时尤为重要。
文件操作（C语言）
2303_76654613的博客
05-19 648
文件 = 文件内容 + 文件属性在程序设计中，文件分为程序文件和数据文件。
【C语言深度解剖】(14)：结构体内存对齐（详细配图讲解）
最新发布
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-20 613
一篇文章带你学会结构体的内存对齐！！超多精美配图！
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 695
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
C++ STL标准库解析｜实现string类的迭代器string::iterator
糖炒栗子
05-17 947
的迭代器标识这样我们也可以遍历到底层的最后一个元素。循环过程中做了++it，说明我们当前迭代器要跳到下一个迭代器来完成遍历，至于它底层到底是数组、链表还是哈希表无论是什么我们都不用管，我们作为使用者只需要对迭代器进行++即可。底层数据结构如何到下一个元素的具体操作都封装在了我们迭代器的++操作中，用户作为使用者是无感的（这就是所谓的透明地访问容器内部元素的值）。最后打印使用迭代器进行解引用。
c语言，java语言，python语言之间有什么区别
2301_78349092的博客
05-17 546
c语言是一般计算机类学生上大一的时候学的第一门编程语言，一般来说相对于另外的俩种语言，大学生对于c语言的认识应该是最深刻的。相比较之下来说三者都是被广泛使用的编程语言，它们之间存在显著的区别。总的来说，C语言的优势在于性能和底层能力，Java的优势在于跨平台和安全性，而Python的优势在于易用性和快速开发。根据项目的具体需求和开发团队的技能基础，选择最合适的编程语言至关重要。在对比C语言、Java和Python的优缺点时，我们可以看到它们各自的特点适用于不同的编程需求和应用场景。
【C++】＜知识点＞ 类的大小计算
致力于Linux的博客
05-18 129
C++中使用sizeof计算类大小的内在说明。
C++中使用open和运算符＞＞读取文本文件
qq_41317716的博客
05-16 385
C++中使用open和运算符>>读取文本文件
P3【知识点】【数据结构】【栈Stack】C++讲解
qq_50891451的博客
05-19 333
1.访问元素（Access） O(1)访问栈顶元素。4.删除元素（delete）O(1) 栈顶元素。2.搜索元素（Search）O(N)3.插入元素（insert）O(1)【496】下一个更大得元素I。
C++并发：构建线程安全的队列
[email protected]的博客
05-15 396
在 threadsafe_queue 的拷贝构造函数中，尽管传入的 other 对象是一个 const 引用，我们仍然需要从这个 const 对象中复制数据。拷贝构造函数需要访问 other 对象的 data_queue，而为了线程安全，必须先锁定 other 的互斥量。由于 mut 是 mutable 的，即使在 const 上下文中，也能执行锁定操作。
红黑树底层封装map、set C++
qq_51216031的博客
05-15 896
map和set底层都是红黑树，其行为都是一致的，问题在于节点数据类型的不同，所以，红黑树的底层迭代器实现都是一样的，设置为模板，因此和问题1的解决思路是一致的。我map要的是key-value模型的BRTree，所以传的是对应的BRTree传对应的模板到Node，实现不同类型的Node节点。模板写成一样的，功能是一样的，但是不同的对象类具体实现不同的功能。我set要用的是key模型的BRTree，所以传的是在各自的map和set写好各自的类，用于模板仿函数的实例化。
vj题单 Color the ball c 差分
2303_79973545的博客
05-15 154
2.wa时可以找一个与自己写的程序的思路接近的正确答案，把正确的代码一步一步地修改成自己的代码，看哪一步开始wa。1.一维前缀和数组，输入原数组，求其一维前缀和数组这两个过程只需要一个数组即可，这样可以降低空间。笔者思路：利用一维差分数组进行区间同时+1的操作，然后还原为一维前缀和数组。3.wa时可以重头思考程序的逻辑是否严谨，是否有一些边界条件未处理到。4.在写程序时，应该想地更全面，一步一步稳步推进，逻辑严谨。1.wa时可以利用一些特殊的数据去测试，如一些边界条件。
1999: 【基础】计算n的阶乘 高精度算法
09-08
计算n的阶乘的高精度算法有多种实现方式，以下是一种常见的方法： 1. 创建一个数组或字符串用于存储计算结果。数组的每个元素或字符串的每个字符代表计算结果的每一位数字。 2. 初始化结果为1。例如，可以将数组或...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值