高精度算法

最新推荐文章于 2022-11-01 20:02:27 发布
最新推荐文章于 2022-11-01 20:02:27 发布
阅读量345 收藏 1
点赞数 2
分类专栏： 算法 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35356840/article/details/122412978
版权

高精度

高精度适用情况

大数的长度最长为 10^6位

  • 高精度加法通过对数位分别储存运算，并维护一个用于处理进位的变量，从而在不造成溢出的前提下实现大数相加。
  • Java和Python中虽然不需要考虑大整数相加的溢出问题，但这种算法的思想很值得借鉴。

高精度储存

  • 从高位对应着 数据中表示也是高位。
  • 当然输出的时候需要倒叙输出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HGw3PIPX-1641802022731)(…/…/…/图库/1590506552684.png)]

int main()
{
    // 使用字符串读入
    string a, b;
    vector<int> A, B;
    cin >> a >> b; //a = "123456"
    // 使用vector逆序读入,变成整数需要减去偏移量0
    for (int i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');//A = [6,5,4,3,2,1]
    for (int i = b.size() - 1; i >= 0; i--) B.push_back(b[i] - '0');
    // 相当于vector<int>
    vector<int> C = add(A, B);
    // 倒序输出
    for (int i = C.size() - 1; i >= 0; i--) printf("%d", C[i]);
    return 0;
}

高精度加法

很简单。就是模拟竖式相加。注意：

  • t为进位
  • 从低到高位计算 c[i] = (A[i] + B[i] + t) % 10, 进位 t = (A[i] + B[i] + t) / 10;
  • 计算完之后如果 t大于0，记得进位加到 c数组最后。
// C = A + B, A >= 0, B >= 0
vector<int> add(vector<int> &A, vector<int> &B)
{
    if (A.size() < B.size()) return add(B, A); //始终保持长的数 + 短的数

    vector<int> C; // vector C 储存和
    int t = 0;
    for (int i = 0; i < A.size(); i ++ )
    {
        t += A[i];//进位累加
        if (i < B.size()) t += B[i]; // 数B没了
        C.push_back(t % 10);
        t /= 10;
    }

    if (t) C.push_back(t);//最高位如果进位
    return C;
}

例题

https://www.acwing.com/problem/content/submission/code_detail/1607027/

#include <bits/stdc++.h>
using namespace std;
// C = A + B, A >= 0, B >= 0

vector<int> add(vector<int> &A, vector<int> &B)
{
    if (A.size() < B.size()) return add(B, A); //始终保持长的数 + 短的数

    vector<int> C; // vector C 储存和
    int t = 0;
    for (int i = 0; i < A.size(); i ++ )
    {
        t += A[i];//进位累加
        if (i < B.size()) t += B[i]; // 数B没了
        C.push_back(t % 10);
        t /= 10;
    }

    if (t) C.push_back(t);//最高位如果进位
    return C;
}
int main()
{
    // 使用字符串读入
    string a, b;
    vector<int> A, B;
    cin >> a >> b; //a = "123456"
    // 使用vector逆序读入,变成整数需要减去偏移量0
    for (int i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');//A = [6,5,4,3,2,1]
    for (int i = b.size() - 1; i >= 0; i--) B.push_back(b[i] - '0');
    // 相当于vector<int>
    vector<int> C = add(A, B);
    // 倒序输出
    for (int i = C.size() - 1; i >= 0; i--) printf("%d", C[i]);
    return 0;
}

高精度减法，A - B(注意需要保证 A >= B)

A-B中两种情况：

image-20210519194622060

A和B对位相减的话，两种情况：

image-20210519194706568

  • 从低位到高位计算 c[i] = (A[i] - B[i] - t) >= 0 ? (A[i] - B[i] - t) % 10 : ((A[i] - B[i] - t) + 10) % 10, 借位 t = (A[i] - B[i] - t) >= 0 ? 0 : 1
  • 注意 : 1、答案有可b能是负数
    ​ 2、最后存储在 vector 中的字符串可能会存在前导 0
#include <iostream>
#include <vector>
using namespace std;

const int N = 1000010;
//判断A是否比B大
bool cmp(vector<int> &A, vector<int> &B)
{
    if (A.size() != B.size()) return A.size() >= B.size();//基础长度比较
    for (int i = A.size() - 1; i >= 0; i--) 
        if (A[i] != B[i])
            return A[i] > B[i];//每个数为值比较
    return true;
}
//去前导零
void trimZero(vector<int> &A)
{
    while (A.back() == 0 && A.size() > 1) A.pop_back();
}

vector<int> sub(vector<int> &A, vector<int> &B)
{
    vector<int> C;//C为A-B的差
    int t = 0;
    for (int i = 0; i < A.size(); i++)
    {
        t = A[i] - t;//减去借位
        if (i < B.size()) t -= B[i]; //前两行实际是 t = A[i] - t - B[i]
        C.push_back((t + 10) % 10);//加上借位,如果t为负，那需要借位的
        if (t < 0) t = 1; //向前借位
        else t = 0;
    }
    trimZero(C);//去除前导0

    return C;
}

int main()
{
    string a, b;
    cin >> a >> b;
    vector<int> A, B, C;
    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)) C = sub(A, B); //若B比A大，将A-B变为B-A，加上负号
    else {
        C = sub(B, A);
        printf("-");
    }
    for (int i = C.size() - 1; i >= 0; i--) cout << C[i];//倒序输出

    return 0;
}

高精度乘法

以123 x 12 为例子

  • 123的每一位都乘以 12
  • c为每一位要输出的数字
  • t为进位
  • 可能有前导0,需要去除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dgIdxush-1641802022737)(…/…/…/图库/1590450263226.png)]

高精度乘以高精度



#include <iostream>
#include <vector>

using namespace std;

vector<int> mul(vector<int> &A, vector<int> &B) {
    // 初始化为 0，且999*99最多 5 位
    vector<int> C(A.size() + B.size(), 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++) { 
        // i = C.size() - 1时 t 一定小于 10
        t += C[i];
        C[i] = t % 10;
        t /= 10;
    }
	// 必须要去前导 0，因为最高位很可能是 0
    while (C.size() > 1 && C.back() == 0) C.pop_back(); 
    return C;
}

int main() {
    string a, b;
    cin >> a >> b; // a = "1222323", b = "2323423423"

    vector<int> 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');

    vector<int> C = mul(A, B);

    for (int i = C.size() - 1; i >= 0; i--)
        cout << C[i]; //倒序输出

    return 0;
}

高精度乘以低精度

#include <iostream>
#include <vector>

using namespace std;

vector <int> mul(vector <int> & A, int b) {
    vector <int> C;

    int t = 0;
    for (int i = 0; i < A.size(); i ++) {
        t += A[i] * b;       // 例如：t + A[i] * b = 7218
        C.push_back(t % 10); // 只取个位 8
        t /= 10;             // 721 看作 进位
    }

    while (t) {            // 处理最后剩余的 t
        C.push_back(t % 10);
        t /= 10;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();

    return C;
}

int main() {
    string a;
    int b;
    cin >> a >> b;

    vector <int> A;
    for (int i = a.size() - 1; i >= 0; i --) A.push_back(a[i] - '0');

   vector <int> C = mul(A, b);

    for (int i = C.size() - 1; i >= 0; i --) {
        cout << C[i];
    }

    return 0;
}

高精度除法

需要带一个余数 r
下一次除的被除数就是 r*10 + A[i]
r = （r*10 + A[i])% b
C[i] =（r*10 + A[i])/ b
从高位开始除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iXXvXAe5-1641802022738)(…/…/…/图库/1590451533408.png)]

// A / b = C ... r, A >= 0, b > 0
vector<int> div(vector<int>& A, int& b, int& r){ // r引用
    vector<int> C;
    r = 0;//r为余数
    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) // 去除前导0
        C.pop_back();
    return C;
}

 
// 高精度除法
#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;
// A被除数 b为除数 r为余数
vector<int> div(vector<int> A, int b, int &r) {
    vector<int> C;
    r = 0; //余数
    for (int i = A.size() - 1; i >= 0; i--) { // 除法是从最高位开始算的
        r = r * 10 + A[i];// 余数*10+当前这一位
        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() {  
    string a;
    int b; //除数
    cin >> a >> b;
    vector<int> A;//被除数
    for (int i = a.size() - 1; i >= 0; i--) {
        A.push_back(a[i] - '0');
    }
    int r; //余数
    vector<int> C = div(A, b, r);
    for (int i = C.size() - 1; i >= 0; i--) {
        cout << C[i];
    }
    cout << endl << r << endl;
    return 0;
}
不会JAVA的运营不是好数分
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++高精度算法
一个平平无奇的博客，一个平平无奇的人，一个平平无奇的约定
10-04 6337
C++高精度加、减、乘、除 大家可以直接拿走，欢迎转载
【C++】高精度算法
最新发布
2401_83006196的博客
02-20 1434
C++高精度算法为我们提供了一种解决超大整数和需要保留多位小数的浮点数计算问题的方法。通过使用字符串或者数组保存数字，并借助进位和借位的方法，我们可以完成加减乘除等各种数学运算。掌握了高精度算法，我们可以在日常生活中更加灵活地处理各种复杂的计算问题。在以后的学习和工作中，我们应该继续深入研究高精度算法，不断提升自己的编程能力。通过不断的练习和实践，我们可以变得更加熟练和精通高精度算法。
高精度算法详解
qq_66314292的博客
11-01 1847
高精度加减乘除
高精度算法——高精度减法
m0_62999279的博客
06-05 6089
高精度减法也同加法一样，也是用于位数太大的运算，给你一个十几位的数你可能会做直接开个long long 的数据类型就解决了，但是给你一个100位的呢，1000位的呢，开long long 也不够了，所以就要用高精度了，也就是高精度算法就是处理位数很大数据。 如果你对高精度加法也不是很熟悉你可以看这个（高精度算法——高精度加法）...
算法详解——高精度算法
hejx0412的博客
04-16 9661
算法详解
高精度算法——高精度加法
热门推荐
m0_62999279的博客
06-03 1万+
高精度可以说除了排序算法以外接触到的第一个算法了，反正我是这样的，高精度主要是用在c/c++，因为Python 是默认无限大的，所以不需要用高精度，JAVA是有库可以调用也是不需要用高精度，其他语言要不要我就不知道了，我也没涉及那么多语言。但是C/C++就不行了，最大也就是unsigned long long也就才(1e19+8e18)位如果要几百位的相加减就不行了，所以就要用高精度了。高精度加法就是完全模拟小学的加法运算，我们先看下小学的加法运算就用123 + 789没毛病吧，我们就完全可以按照这个来模拟
高精度算法——高精度乘法
m0_62999279的博客
06-08 5886
高精度乘法，会比高精加法、减法稍微难那么一点点，主要是乘法要用到，高精度加法去做，也就是说，如果高精度加法没有学好，高精度乘法也就会有点难理解了，但是吧，你既然搜到了并点到了这里，就说明你已经会高精度加法了，既然你已经会高精度加法了，就说明你知道为什么要用高精度了，就不再多说废话了。 顺便把这题完整的代码也附上把：...
C++算法(高精度算法)
博客
05-01 3616
C++高精度算法
c语言高精度算法（加法）
程伟耀的博客
12-17 6975
1.为什么使用高精度算法啊？ 在c语言中，int类型取值范围为（-2^31 ~ 2^31-1），而long long类型取值范围也才仅有（-2^63~ 2^63-1），在处理一些较大的数据时，显然仅靠这些类型，是完全无法处理的 2.高精度加法的核心思想（图解） 3.高精度算法的核心思想 其实就是用数组来处理高精度问题 将很大的数字用字符数组存储，再将其中一个个的数字变为整数存入整形数组中 4.准备工作 1.要输入东西 ...
acm.rar_高精度算法
09-24
在ACM（国际大学生程序设计竞赛）中，高精度算法是一种关键技能，它涉及处理大整数的运算，包括加法、减法、乘法和除法。这些运算在常规的计算机语言中可能会超出整数类型的限制，因此需要特别的设计和实现。下面将...
部分高精度算法c语言.doc
11-29
部分高精度算法C语言实现 本文档介绍了三个高精度算法的C语言实现，分别是高精度除以低精度、 高精度乘以高精度和高精度除以高精度。 一、高精度除以低精度 该算法按照从高位到低位的顺序，逐位相除。在除到第j位...
C/C++高精度算法的实现
12-20
做ACM题的时候，经常遇到大数的加减乘除，乘幂，阶乘的计算，这时给定的数据类型往往不够表示最后结果，这时就需要用到高精度算法。高精度算法的本质是把大数拆成若干固定长度的块，然后对每一块进行相应的运算。...
二分图原理及应用
马丘
06-03 3896
二分图 什么是二分图？ G=(V, E)，其中G代表图，V代表这个图的所有顶点的集合，E代表这个图所有连线的集合，即是边集。现如今如果能将V这个顶点集分成两个互不相交的子集A、B，E这个边集内所有边的两个顶点分别属于*A、B两个子集的话，我们就称这个图为二分图。 要点 无向图 所有点分成A,B两个不相交的集合 所有边，都在着两个集合之间。 同一个集合不能有边。 二分图应用 如何检测二分图？ 染色 二分图最大匹配？匈牙利算法 如何检测二分图？ 染色法 如果我们能够把图中的所有顶点分成两部分，
区间合并原理和规律
马丘
06-02 2130
区间合并 题目很好理解： 我们解决区间问题的一般思路是先排序，然后观察规律 想法 贪心 具体就是按着起点排序 如果前一个终点< 下一个起点。那么单独成为一个区间。更新 起点 如果前一个终点>= 下一个起点. max(end1,end2)。更新终点 一个区间可以表示为 [start, end]，以便满足贪心选择性质。而对于区间合并问题，其实按 end 和 start 排序都可以，不过为了清晰起见，我们选择按 start 排序。 排序完成后： 简单来说就是这样： #include<io
双指针原理和应用
马丘
06-02 1960
双指针 双指针算法思想 实用i,j两个变量，不会退的扫描一个数组 常规写法 for(int i=0,j=0,i<n;i++){ while(j<i&&check(i,j)) j++; } 这是i,j分别两端的写法 int i=0,j=n-1; while(i<j){ if(check(i,j)) i++; else j--; } 双指针应用分类 常见问题分类： ​ (1) 对于一个序列，用两个指针维护一段区间 ​ (2) 对于两个序列
scanf读取字符的技巧——防止有字符前有空格
马丘
11-17 1769
scanf读取字符的技巧——防止有字符前有空格 问题背景： 经常读入数据的时候，会遇到scanf读入数据带有间隔情况，如下： 输入：x x x 或者 x x x 此时只有一个或者多个空格，那么： 解决方法： 使用cin 或者使用 scanf(" %c",&c); ' '是可以忽略一个或者多个空格 #include<bits/stdc++.h> using namespace std; char c; int main(){ for (int i = 0; i < 3;
离散化原理
马丘
06-02 1278
离散化 背景 适用范围：数组中元素数值很大，但个数不是很多。 比如将a[]=[1,3,100,2000,500000]映射到[0,1,2,3,4]这个过程就叫离散化。 算法思想 本质是一种哈希算法 离散化，就是当我们只关心数据的大小关系时，用排名代替原数据进行处理的一种预处理方法。离散化本质上是一种哈希，它在保持原序列大小关系的前提下把其映射成正整数。当原数据很大或含有负数、小数时，难以表示为数组下标，一些算法和数据结构（如BIT）无法运作，这时我们就可以考虑将其离散化。 离散化的关键问题： 1.a[]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值