高精度HighAccuracy【算法模板笔记】

已于 2022-11-19 19:04:14 修改
阅读量111 收藏
点赞数
分类专栏： # 入门算法 文章标签： 算法 c++ 蓝桥杯 学习 数据结构
于 2022-11-19 19:03:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49320014/article/details/127940298
版权 
/*HighAccuracy_oiwiki.cpp*/
#include <cstdio>
#include <cstring>

static const int LEN = 10005;// 定义静态的长度变量LEN

int a[LEN], b[LEN], c[LEN], d[LEN];// 定义高精度数组

void clear(int a[]) {// 高精度数组清零操作
    for (int i = 0; i < LEN; ++i) a[i] = 0;
}


bool cmp(int a[], int b[])// 高精度比较函数
{
    for (int i = LEN - 1; i >= 0; --i){
        if (a[i] > b[i]) return true;
        if (a[i] < b[i]) return false;
    }
    return true;
}

void read(int a[]) {// 输入高精度数
    static char s[LEN + 1];
    scanf("%s", s);

    clear(a);

    int len = strlen(s);
    for (int i = 0; i < len; ++i) a[len - i - 1] = s[i] - '0';//实现了倒序，即个十百千万0000···
}

void print(int a[]) {// 输出高精度数
    int i;
    for (i = LEN - 1; i >= 1; --i)//去掉后面的零，即 个十百千万0000··· 变成 个十百千万
        if (a[i] != 0) break;
    for (; i >= 0; --i) putchar(a[i] + '0');
    putchar('\n');
}

void add(int a[], int b[], int c[]) {// 高精度加法（高精度加高精度）
    clear(c);

    for (int i = 0; i < LEN - 1; ++i) {
        c[i] += a[i] + b[i];
        if (c[i] >= 10) {
            c[i + 1] += 1;
            c[i] -= 10;
        }
    }
}

void sub(int a[], int b[], int c[]) {// 高精度减法（高精度减高精度）
    clear(c);

    for (int i = 0; i < LEN - 1; ++i) {
        c[i] += a[i] - b[i];
        if (c[i] < 0) {
            c[i + 1] -= 1;
            c[i] += 10;
        }
    }
}

void mul(int a[], int b[], int c[]) {// 高精度乘法（高精度乘以高精度）
    clear(c);

    for (int i = 0; i < LEN - 1; ++i) {
        for (int j = 0; j <= i; ++j) c[i] += a[j] * b[i - j];

        if (c[i] >= 10) {
            c[i + 1] += c[i] / 10;
            c[i] %= 10;
        }
    }
}

inline bool greater_eq(int a[], int b[], int last_dg, int len) {// 判断大小数组（具体原理请参照OIwiki）
  if (a[last_dg + len] != 0) return true;
  for (int i = len - 1; i >= 0; --i) {
    if (a[last_dg + i] > b[i]) return true;
    if (a[last_dg + i] < b[i]) return false;
  }
  return true;
}

void div(int a[], int b[], int c[], int d[]) {// 高精度除法（高精度除以高精度）
  clear(c);
  clear(d);

  int la, lb;
  for (la = LEN - 1; la > 0; --la)
    if (a[la - 1] != 0) break;
  for (lb = LEN - 1; lb > 0; --lb)
    if (b[lb - 1] != 0) break;
  if (lb == 0) {
    puts("> <");
    return;
  }

  for (int i = 0; i < la; ++i) d[i] = a[i];
  for (int i = la - lb; i >= 0; --i) {
    while (greater_eq(d, b, i, lb)) {
      for (int j = 0; j < lb; ++j) {
        d[i + j] -= b[j];
        if (d[i + j] < 0) {
          d[i + j + 1] -= 1;
          d[i + j] += 10;
        }
      }
      c[i] += 1;
    }
  }
}

int main() {
    freopen("luogu_in.txt","r",stdin);  // 文件输入  
    freopen("luogu_out.txt","w",stdout);// 文件输出  
    read(a);

    char op[4];
    scanf("%s", op);

    read(b);

    switch (op[0]) {
        case '+':
            add(a, b, c);
            print(c);
            break;
        case '-':
            if(cmp(a, b)) sub(a, b, c);
            else{
               printf("-");
              sub(b, a, c);
            }
            print(c);
            break;
        case '*':
            mul(a, b, c);
            print(c);
            break;
        case '/':
            div(a, b, c, d);
            print(c);
            print(d);
            break;
        default:
            puts("> <");
    }

    return 0;
}
/*HighAccuracy_acwing.cpp*/
#include<bits/stdc++.h>
using namespace std;


bool sub_plus(vector<int> &a, vector<int> &b){//0表示负数，1表示正数
    if(a.size()<b.size()) return 0;
    if(a.size()==b.size()){
        for(int i = 0; i<a.size(); i++){
            if(a[i]<b[i]){
                return 0;
            }
        }
    }
    return 1;
}

vector<int> add(vector<int> &A, vector<int> &B){  //正序输入两个vector类型的“数”
    if (A.size() < B.size()) return add(B, A);  //使得A数组是最大的
    //如果未反转，在if下面加reverse，不能在if上面加reverse，否者二次反转，等于没有反转

    reverse(A.begin(),A.end());  //反转数组,变成个十百千万···
    reverse(B.begin(),B.end());
    vector<int> 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);//最后一次加法可能还有进位的数，把最高位补上
    while (c.size() > 1 && c.back() == 0) c.pop_back();//处理前导零
    reverse(c.begin(), c.end());
    return c;
}

// C = A - B, 满足A >= B, A >= 0, B >= 0
vector<int> sub(vector<int> &A, vector<int> &B){
    reverse(A.begin(),A.end());  //反转数组,变成个十百千万···
    reverse(B.begin(),B.end());
    vector<int> C;
    for (int i = 0, t = 0; i < A.size(); i++ ){
        t = A[i] - t;
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);//无论如何，先向高位借1
        if (t < 0) t = 1;//t是负数，说明是真的借1了
        else t = 0;//t是非负数，说明不用借1
    }
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    reverse(C.begin(), C.end());
    return C;
}

//不清楚c数组开多大
vector<int> multwo(vector<int> &a, vector<int> &b){
    if(a.size()<b.size()) return multwo(b,a);
    vector<int> c(1000001,0);  //初始化答案数组（不知道开多大）
    reverse(a.begin(), a.end());  //反转数组,变成个十百千万···
    reverse(b.begin(), b.end());
    int t = 0;
    for(int i = 0; i<b.size(); i++){  //b数组数少，是外循环
        for(int j = 0; j<a.size() || t; j++){  //a数组数多，是内循环
            if(j<a.size()) t += a[j]*b[i];
            c[j+i] += t % 10;
            t /= 10;
        }
    }
    //处理c数组的进位
    for(int i = 0; i<a.size()*b.size(); i++){  //无论数字如何大，数位也不会大于两个乘数的和
        if(c[i]>9){
            c[i+1]+=c[i]/10;
	        c[i]%=10;
        }
    }
    while (c.size() > 1 && c.back() == 0) c.pop_back();  //末尾可能是0，都要去掉（我感觉是多余的，不可能有这种情况）(难道是处理b==0？)
    reverse(c.begin(), c.end());
    return c;
}

/*除法*/
// A / b = C ... r, A >= 0, b > 0
vector<int> div(vector<int> &A, int b, int &r){
    reverse(A.begin(), A.end());
    vector<int> C;
    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();
    reverse(C.begin(), C.end());//高位在左，低位在右
    return C;
}

int main(){
    string in; getline(cin,in);
    vector<int> a;
    vector<int> b;
    vector<int> c;
    char f;
    int i;

    for(i = 0; i<in.size(); i++){
        if(in[i]!=' ') a.push_back(in[i]-'0');
        else break;
    }

    i++;
    f = in[i];
    i+=2;

    for(i; i<in.size(); i++) b.push_back(in[i]-'0');

    switch (f) {
        case '+':
            c = add(a,b);
            break;
        case '-':
            //增加负号
            if(!sub_plus(a,b)){
                printf("-");
                c = sub(b,a);
            }
            else c = sub(a,b);
            break;
        case '*':
            c = multwo(a,b);
            break;
        case '/':
            int bb = b[0]; int d;
            c = div(a,bb,d);
            break;
        // default:
        //     puts("> <");
    }
    for(int i = 0; i<c.size(); i++) printf("%d", c[i]);

    return 0;
}

/*

*/
/*HighAccuracy_additional.cpp*/
#include<bits/stdc++.h>
using namespace std;


// C = A + B, A >= 0, B >= 0
//这里不加&，就可以避免改变了原来的a，b数组，使得a，b数组可以重复利用
vector<int> add(vector<int> A, vector<int> B){  //正序输入两个vector类型的“数”
    if (A.size() < B.size()) return add(B, A);  //使得A数组是最大的
    //如果未反转，在if下面加reverse，不能在if上面加reverse，否者二次反转，等于没有反转
    
    reverse(A.begin(),A.end());  //反转数组,变成个十百千万···
    reverse(B.begin(),B.end());
    vector<int> 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);//最后一次加法可能还有进位的数，把最高位补上
    reverse(c.begin(), c.end());
    return c;
}

string add(string a, string b){
    if(a.size()<b.size()) return add(b,a);
    reverse(a.begin(),a.end());
    reverse(b.begin(),b.end());
    int t = 0;
    string c;
    for(int i = 0; i<a.size(); i++){
        t += a[i] - '0';
        if(i<b.size()) t+=b[i] - '0';
        c.push_back(t%10 + '0');
        t /= 10;
    }
    if(t) c.push_back(t + '0');
    reverse(c.begin(), c.end());
    return c;
}

// C = A - B, 满足A >= B, A >= 0, B >= 0
vector<int> sub(vector<int> A, vector<int> B){
    reverse(A.begin(),A.end());  //反转数组,变成个十百千万···
    reverse(B.begin(),B.end());
    vector<int> C;
    for (int i = 0, t = 0; i < A.size(); i++ ){
        t = A[i] - t;
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);//无论如何，先向高位借1
        if (t < 0) t = 1;//t是负数，说明是真的借1了
        else t = 0;//t是非负数，说明不用借1
    }
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    reverse(C.begin(), C.end());
    return C;
}

/*高精度乘低精度 —— 模板题*/
// C = A * b, A >= 0, b >= 0
vector<int> mul(vector<int> A, int b){  //输入正序的高精度A和低精度b
    vector<int> C;  //初始化答案数组
    reverse(A.begin(),A.end());  //反转数组,变成个十百千万···
    int t = 0;
    for (int i = 0; i < A.size() || t; i++ ){  //A数组还有数 或 t还有数
        if (i < A.size()) t += A[i] * b;  //如果 A数组还有数
        C.push_back(t % 10);
        t /= 10;
    }
    while (C.size() > 1 && C.back() == 0) C.pop_back();  //末尾可能是0，都要去掉（我感觉是多余的，不可能有这种情况）(难道是处理b==0？)
    reverse(C.begin(),C.end());  //反转数组,恢复正序
    return C;
}

string mul(string a, int b){
    reverse(a.begin(), a.end());
    string c;
    int t = 0;
    for(int i = 0; i<a.size() || t; i++){
        if(i<a.size()) t += (a[i] - '0') * b;
        c.push_back(t%10 + '0');
        t /= 10;
    }
    while(c.size()>1 && c.back() == 0)c.pop_back();
    reverse(c.begin(), c.end());
    return c;
}

//不清楚c数组开多大
vector<int> multwo(vector<int> a, vector<int> b){
    if(a.size()<b.size()) return multwo(b,a);
    vector<int> c(10001,0);  //初始化答案数组（不知道开多大）
    reverse(a.begin(), a.end());  //反转数组,变成个十百千万···
    reverse(b.begin(), b.end());
    int t = 0;
    for(int i = 0; i<b.size(); i++){  //b数组数少，是外循环
        for(int j = 0; j<a.size() || t; j++){  //a数组数多，是内循环
            if(j<a.size()) t += a[j]*b[i];
            c[j+i] += t % 10;
            t /= 10;
        }
    }
    //处理c数组的进位
    for(int i = 0; i<a.size()*b.size(); i++){  //无论数字如何大，数位也不会大于两个乘数的和
        if(c[i]>9){
            c[i+1]+=c[i]/10;
	        c[i]%=10;
        }
    }
    while (c.size() > 1 && c.back() == 0) c.pop_back();  //末尾可能是0，都要去掉（我感觉是多余的，不可能有这种情况）(难道是处理b==0？)
    reverse(c.begin(), c.end());
    return c;
}

/*除法*/
// A / b = C ... r, A >= 0, b > 0
vector<int> div(vector<int> &A, int b, int &r){
    reverse(A.begin(), A.end());
    vector<int> C;
    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();
    reverse(C.begin(), C.end());//高位在左，低位在右
    return C;
}



int main(){
    //加法
    vector<int> addint1 = {1,2,3,4,5,6,7,8,9};
    vector<int> addint2 = {9,8,7,6,5,4,3,2,1,0};
    vector<int> addint3 = add(addint1,addint2);
    for(int i = 0;i<addint3.size(); i++) cout<<addint3[i];
    printf("\n");

    //加法
    string addstr1 = {"123456789"};
    string addstr2 = {"9876543210"};
    string addstr3 = add(addstr1,addstr2);
    cout<< addstr3 <<endl;

    //减法
    vector<int> subint1 = {9,8,7,6,5,4,3,2,1,0};
    vector<int> subint2 = {9,0,7,0,5,0,3,0,1,0};
    vector<int> subint3 = sub(subint1,subint2);
    for(int i = 0;i<subint3.size(); i++) cout<<subint3[i];
    printf("\n");

    //乘法(高精度*低精度)
    vector<int> mulint1 = {9,0,0,8,0,0,7,0,0,6,0,0,5,0,0,4,0,0,3,0,0,2,0,0,1};
    int mulint2 = 9;
    vector<int> mulint3 = mul(mulint1,mulint2);
    for(int i = 0;i<mulint3.size(); i++) cout<<mulint3[i];
    printf("\n");

    //乘法(高精度*低精度)
    string mulstr1 = "9008007006005004003002001";
    int mulstr2 = 9;
    cout<<mul(mulstr1,mulstr2)<<endl;

    //乘法(高精度*高精度)
    vector<int> multwo1 = {1,2,3,4,5,6,7,8,9};
    vector<int> multwo2 = {1,2,3,4,5,6,7,8,9};
    vector<int> multwo3 = multwo(multwo1,multwo2);
    for(int i = 0;i<multwo3.size(); i++) cout<<multwo3[i];
    printf("\n");
    
    //除法（高精度/低精度）
    vector<int> divint1 = {8,1,0,7,2,0,6,3,0,5,4,0,4,5,0,3,6,0,2,7,0,1,8,0,0,9};
    int divint2 = 9;
    int divintr = 0;
    vector<int> divint3 = div(divint1,divint2,divintr);
    for(int i = 0;i<divint3.size(); i++) cout<<divint3[i];
    printf("\n");

    return 0;
}

 

唔想起名
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法笔记（四）：高精度
Cooperia的博客
07-17 1380
（3）高精度算法 目录 1、高精度算法 高精度算法介绍 高精度与竖式计算 进位和前导零 2、高精度数的加减乘除 高精度加法 高精度减法 高精度乘法 高精度除法 写在最后！！！ 1、高精度算法 高精度算法介绍 高精度算法（High Accuracy Algorithm）是处理大数字的一种数学计算方法，是用计算机对于超大数字的一种模拟加减乘除等的运算。但是计算机无法正常存储非常庞大的数字，便把数字进行拆分存储到一个数组找那个，用一个数组去表示一个数字，这样的数字便是高精度数。简言.
数字处理算法之高精度
Michael888888ha的博客
04-11 843
高精度算法，干货满满
算法入门系列 C/C++语言的高精度加法(1/4)
qq_63561301的博客
07-21 636
如图我们知道了怎么把很长的数据存储下来我们这里非常有必要再用一张图来解释为什么需要逆序处理? 首先long long 肯定不行,所以我们可以用字符串接收 (2)怎么把字符串给处理?逆序存入数组? (3)数组加法函数的实现
高精度运算学习笔记
Richard_1101的博客
07-29 375
什么是高精度运算 高精度算法（High Accuracy Algorithm）是处理大数字的数学计算方法。在一般的科学计算中，会经常算到小数点后几百位或者更多，当然也可能是几千亿几百亿的大数字。一般这类数字我们统称为高精度数，高精度算法是用计算机对于超大数据的一种模拟加，减，乘，除，乘方，阶乘，开方等运算。对于非常庞大的数字无法在计算机中正常存储，于是，将这个数字拆开，拆成一位一位的，或者是四位四位的存储到一个数组中， 用一个数组去表示一个数字，这样这个数字就被称为是高精度数。高精度算法就是能处理高精度数
《FaceBoxes: A CPU Real-time Face Detector with High Accuracy》论文笔记
会飞的鱼的博客
02-05 2257
FaceBoxes: A CPU Real-time Face Detector with High Accuracy
Visual SLAM算法笔记
热门推荐
MulinB的技术博客
12-23 3万+
最近在学习SLAM算法，这里作为阅读笔记记录和总结一下。对经典的单目SLAM/VO算法做了摘要和总结，比如Nister VO、MonoSLAM、PTAM、ORB-SLAM、LSD-SLAM、SVO、DSO等，对几个单目和IMU的融合算法也做了简单总结，比如MSCKF、OKVIS、IMU-Preintegration等。
【论文笔记】A High-Accuracy Indoor-Positioning Method with Automated RGB-D Image Database Construction
weixin_44413191的博客
07-31 323
论文《A High-Accuracy Indoor-Positioning Method with Automated RGB-D Image Database Construction》学习笔记
机器学习笔记 十六：基于Boruta算法的随机森林（RF）特征重要性评估
amyniez的博客，欢迎交流讨论
11-10 5371
随机森林由许多决策树组成，决策树中的每个节点都是单个特征的一个条件，旨在将数据集分成两个，以便相似的响应值最终出现在相同的集合中。选择(局部)最优条件所依据的度量称为杂质：1.对于分类树，它通常是基尼杂质或信息增益/熵；对于每一列，重复排列10次，以便对平均精度下降(MDA)有一个更好的估计，并计算该估计的标准差。
计算机常用算法对照表整理
IT届的小学生
07-26 1万+
常用对照：NLP CRF算法: 中文名称条件随机场算法，外文名称conditional random field algorithm，是一种数学算法，是2001年提出的，基于遵循马尔可夫性的概率图模型。 全部对照第一部分、计算机算法常用术语中英对照 Data Structures 基本数据结构 Dictionaries 字典 Priority Queues 堆 Graph Data
高精度算法(high precision algorithm)
07-14
自己编的高精度，有点小问题，大佬可以帮忙看一看，蒟蒻可以直接拿走（除了div和mod以外），喜欢的记得三联哦（你的收藏是我最大的动力）
高精度算法
03-21
同时，高精度算法也可以用于解决一些复杂的数学问题，例如高精度矩阵运算、_high-precision_ Fourier 变换等。 高精度算法是计算机科学中一个非常重要的领域，它可以解决一些复杂的数学问题，提高计算的精度和效率...
gaojingdu.zip_高精度_高精度算法 c_高精度计算
09-21
在计算机科学中，高精度计算（High-Precision Computing）是指使用大整数或者浮点数进行精确计算的方法，通常涉及到的领域包括数学、物理、工程、金融等需要精确计算的场景。在C语言中实现高精度算法，需要设计一套...
c++（NOIP）高精度加法源代码
12-23
高精度算法(High Accuracy Algorithm)是处理大数字的数学计算方法。在一般的科学计算中,会经常算到小数点后几百位或者更多,当然也可能是几千亿几百亿的大数字。一般这类数字我们统称为高精度数,高精度算法是用计算机...
高精度的光学传递函数计算
02-11
直接从基尔霍夫衍射积分理论出发,在数学模型上考虑了瞳面振幅分布的不均匀性和倾斜因子,并采取一系列改进数值计算方法的措施,力求光学传递函数(OTF)计算的高精度。通过对多个同类软件和多个典型镜头进行比对计算和...
【排序算法】插入排序（希尔排序）
2301_80555259的博客
07-07 658
直接插入排序是一种简单的插入排序法，其核心思想是对一个已经有序的序列插入一个数据，该数据依次比较有序序列中的值，直到插入到合适的位置。在我们玩扑克牌整理牌序的时候，用到的就是直接插入排序的思想。
D1.排序
最新发布
2302_79232710的博客
07-07 213
快速排序和归并排序
十一、作业
weixin_58543820的博客
07-07 488
计算1/1-1/2+1/3-1/4+1/5 ……+ 1/99 - 1/100 的值，打印出结果。编写程序数一下 1到 100 的所有整数中出现多少个数字9。要求：找到了就打印数字所在的下标，找不到则输出：找不到。写一个代码打印1-100之间所有3的倍数的数字。编写代码在一个整形有序数组中查找具体的某个数。打印1000年到2000年之间的闰年。写代码将三个整数数按从大到小输出。给定两个数，求这两个数的最大公约数。最小公倍数=a*b/最大公约数。在屏幕上输出9*9乘法口诀表。%-2d - 左对齐。
算法库应用--Brute - Force算法串匹配(顺序串)
qq_57484399的博客
07-06 928
V1.0: 在原有的博客基础上, 加入我构建的算法库, 让博客更完全 , 代码可以运行看效果, 不是让算法仅仅停留在 逻辑方面, 这也是后续我努力的方向, 把这些算法模型, 尽可能的去运用到实际的嵌入式项目中, 把理论变成实物 , 本次也进行了名字优化, 让逻辑更清晰。利用B-f算法,寻找子串在母串中的位置。
fundamentals of high accuracy inertial navigation pdf
07-28
《高精度惯性导航的基础》是一本关于惯性导航系统基本原理的重要资源。惯性导航是一种通过测量物体加速度和角速度来确定其位置、速度和方向的技术。该书详细介绍了惯性导航系统中的几个关键概念和技术。 首先，该书...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值