高精度模板

最新推荐文章于 2023-09-30 11:15:33 发布
置顶 最新推荐文章于 2023-09-30 11:15:33 发布
阅读量455 收藏
点赞数 2
分类专栏： 模板 文章标签： 模板 高精度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanghongMO/article/details/51892286
版权

2016-9-28


由于某些不可抗力,2016-9-25的代码是废的(有很多地方写错了)
于是我又写了一个新的.

#include <iostream>
#include <iomanip>
#include <cstring>
using namespace std;
class bigint {

    int sz;
    int len,num[1000];


    public:
        bigint() {
            sz=10000;
            memset(num,0,sizeof(num));
            len=0;
        }
        long long operator = (const long long &tmp) {
            long long val;
            val=tmp;
            len=0;
            memset(num,0,sizeof(num));
            while (val) {
                num[len]=val%sz;
                len++;
                val/=sz;
            }
            return tmp;
        }

        template <class T1,class T2> friend bigint operator + (const T1 &A,const T2 &B);
        template <class T> friend bigint operator += (bigint &A,const T &B);
        template <class T1,class T2> friend bigint operator * (const T1 &A,const T2 &B);
        template <class T> friend bigint operator *= (bigint &A,const T &B);
        template <class T1,class T2> friend bool operator < (const T1 &A,const T2 &B);
        template <class T1,class T2> friend bool operator > (const T1 &A,const T2 &B);
        template <class T1,class T2> friend bool operator <= (const T1 &A,const T2 &B);
        template <class T1,class T2> friend bool operator >= (const T1 &A,const T2 &B);
        template <class T1,class T2> friend bool operator == (const T1 &A,const T2 &B);
        template <class T1,class T2> friend bool operator != (const T1 &A,const T2 &B);
        friend istream &operator >> (istream &in,bigint &tmp);
        friend ostream &operator << (ostream &out,const bigint &tmp);
};

template <class T1,class T2> bigint operator + (const T1 &t1,const T2 &t2) {
    bigint A,B;
    A=t1,B=t2;
    bigint ans;
    ans.len=max(A.len,B.len);
    for(int i=0;i<ans.len;i++){
        ans.num[i]+=A.num[i]+B.num[i];
        if(ans.num[i]>=ans.sz){
            ans.num[i]-=ans.sz;
            ans.num[i+1]++;
        }
    }
    if(ans.num[ans.len]>0)ans.len++;
    return ans;
}

template <class T> bigint operator += (bigint &A,const T &B) {
    A=A+B;
    return A;
}

template <class T1,class T2> bigint operator * (const T1 &t1,const T2 &t2) {
    bigint A,B;
    A=t1,B=t2;
    bigint ans;
    for(int i=0;i<A.len;i++){
        for(int j=0;j<B.len;j++){
            ans.num[i+j]+=A.num[i]*B.num[j];
            ans.num[i+j+1]+=ans.num[i+j]/ans.sz;
            ans.num[i+j]%=ans.sz;
        }
    }
    ans.len=A.len+B.len-1;
    if(ans.num[ans.len]>0)ans.len++;
    while(ans.len>=2&&ans.num[ans.len-1]==0)ans.len--;
    return ans;
}

template <class T> bigint operator *= (bigint &A,const T &B) {
    A=A*B;
    return A;
}

template <class T1,class T2> bool operator < (const T1 &t1,const T2 &t2) {
    bigint A,B;
    A=t1,B=t2;
    if (A.len<B.len) return 1;
    else if (A.len>B.len) return 0;
    for (int i=0;i<A.len;++i) {
        if (A.num[i]<B.num[i]) return 1;
        else if (A.num[i]>B.num[i]) return 0;
    }
    return 0;
}

template <class T1,class T2> bool operator > (const T1 &t1,const T2 &t2) {
    bigint A,B;
    A=t1,B=t2;
    if (A.len<B.len) return 0;
    else if (A.len>B.len) return 1;
    for (int i=0;i<A.len;++i) {
        if (A.num[i]<B.num[i]) return 0;
        else if (A.num[i]>B.num[i]) return 1;
    }
    return 0;
}

template <class T1,class T2> bool operator == (const T1 &t1,const T2 &t2) {
    bigint A,B;
    A=t1,B=t2;
    if (A.len!=B.len) return 0;
    for (int i=0;i<A.len;++i) if (A.num[i]!=B.num[i]) return 0;
    return 1;
}

template <class T1,class T2> bool operator != (const T1 &t1,const T2 &t2) {
    bigint A,B;
    A=t1,B=t2;
    if (A.len!=B.len) return 1;
    for (int i=0;i<A.len;++i) if (A.num[i]!=B.num[i]) return 1;
    return 0;
}

template <class T1,class T2> bool operator <= (const T1 &A,const T2 &B) {
    return A==B||A<B;
}

template <class T1,class T2> bool operator >= (const T1 &A,const T2 &B) {
    return A==B||A>B;
}

istream &operator >> (istream &in,bigint &tmp) {
    string str;
    in>>str;
    int l=str.length();
    tmp.len=0;
    memset(tmp.num,0,sizeof(tmp.num));
    for(int i=l-1;i>=0;i-=4){
        int p=0;
        for(int j=max(0,i-3);j<=i;j++)
            p=p*10+(str[j]^48);
        tmp.num[tmp.len++]=p;
    }
    return in;
}
ostream &operator << (ostream &out,const bigint &tmp) {
    out<<tmp.num[tmp.len-1];
    for (int i=tmp.len-2;i>=0;i--) {
        out<<setfill('0')<<setw(4)<<tmp.num[i];
    }
    return out;
}

2016-9-25

更新了一下,但是符号优先级好像很奇怪

bigintA=100;

就会出问题,但
bigintA;

A=100;

就没事.
(此代码已废) 

#include <iostream>
#include <iomanip>
#include <cstring>
using namespace std;
struct bigint {
    int sz;
    int len,num[1000];
    bigint(int key=10000) {
        sz=key;
        len=0;
        memset(num,0,sizeof(num));
    }
    long long operator = (const long long &tmp) {
        int val;
        val=tmp;
        len=0;
        memset(num,0,sizeof(num));
        while (val) {
            num[len]=val%sz;
            len++;
            val/=sz;
        }
        return tmp;
    }
    friend istream &operator >> (istream &in,bigint &tmp);
    friend ostream &operator << (ostream &out,const bigint &tmp);
};
template <class T> bigint operator + (const bigint &x,const T &t) {
    bigint tmp;
    tmp=t;
    bigint ans;
    ans.len=max(x.len,tmp.len);
    for(int i=0;i<ans.len;i++){
        ans.num[i]+=x.num[i]+tmp.num[i];
        if(ans.num[i]>=ans.sz){
            ans.num[i]-=ans.sz;
            ans.num[i+1]++;
        }
    }
    if(ans.num[ans.len]>0)ans.len++;
    return ans;
}
template <class T> bigint operator + (const T &t,const bigint &x) {
    return x+t;
}
template <class T> bigint operator * (const bigint &x,const T &t) {
    bigint tmp;
    tmp=t;
    bigint ans;
    for(int i=0;i<x.len;i++){
        for(int j=0;j<tmp.len;j++){
            ans.num[i+j]+=x.num[i]*tmp.num[j];
            ans.num[i+j+1]+=ans.num[i+j]/ans.sz;
            ans.num[i+j]%=ans.sz;
        }
    }
    ans.len=x.len+tmp.len-1;
    if(ans.num[ans.len]>0)ans.len++;
    while(ans.len>=2&&ans.num[ans.len-1]==0)ans.len--;
    return ans;
}
template <class T> bigint operator * (const T &t,const bigint &x) {
    return x*t;
}
template <class T> bool operator == (const bigint &x,const T &t) {
    bigint tmp;
    tmp=t;
    if (x.len!=tmp.len) return 0;
    for (int i=0;i<x.len;++i) if (x.num[i]!=tmp.num[i]) return 0;
    return 1;
}
template <class T> bool operator == (const T &t,const bigint &x) {
    return x==t;
}
template <class T> bool operator != (const bigint &x,const T &t) {
    bigint tmp;
    tmp=t;
    if (x.len!=tmp.len) return 1;
    for (int i=0;i<x.len;++i) if (x.num[i]!=tmp.num[i]) return 1;
    return 0;
}
template <class T> bool operator != (const T &t,const bigint &x) {
    return x!=t;
}
template <class T> bool operator < (const bigint &x,const T &t) {
    bigint tmp;
    tmp=t;
    if (x.len<tmp.len) return 1;
    else if (x.len>tmp.len) return 0;
    for (int i=0;i<x.len;++i) {
        if (x.num[i]<tmp.num[i]) return 1;
        else if (x.num[i]>tmp.num[i]) return 0;
    }
    return 0;
}
template <class T> bool operator > (const bigint &x,const T &t) {
    bigint tmp;
    tmp=t;
    if (x.len<tmp.len) return 0;
    else if (x.len>tmp.len) return 1;
    for (int i=0;i<x.len;++i) {
        if (x.num[i]<tmp.num[i]) return 0;
        else if (x.num[i]>tmp.num[i]) return 1;
    }
    return 0;
}
template <class T> bool operator < (const T &t,const bigint &x) {
    return x>t;
}
template <class T> bool operator > (const T &t,const bigint &x) {
    return x<t;
}
istream &operator >> (istream &in,bigint &tmp) {
    string str;
    in>>str;
    int l=str.length();
    tmp.len=0;
    memset(tmp.num,0,sizeof(tmp.num));
    for(int i=l-1;i>=0;i-=4){
        int p=0;
        for(int j=max(0,i-3);j<=i;j++)
            p=p*10+(str[j]^48);
        tmp.num[tmp.len++]=p;
    }
    return in;
}
ostream &operator << (ostream &out,const bigint &tmp) {
    out<<tmp.num[tmp.len-1];
    for (int i=tmp.len-2;i>=0;i--) {
        out<<setfill('0')<<setw(4)<<tmp.num[i];
    }
    return out;
}

2016-7-12

仅仅只是高精度模板 -_-||

struct BigInt {
    int num[100];
    int len;
    BigInt() {
        memset(num,0,sizeof(num));
    }
    void get(int x) {
        memset(num,0,sizeof(num));
        num[0]=x;
        len=1;
    }
    void Rd() {
        char str[400];
        scanf("%s",str);
        int l=strlen(str);
        len=0;
        for(int i=l-1; i>=0; i-=4) {
            int p=0;
            for(int j=max(0,i-3); j<=i; j++)
                p=p*10+(str[j]-'0');
            num[len++]=p;
        }
    }
    void Print() {
        printf("%d",num[len-1]);
        for(int i=len-2; i>=0; i--)
            printf("%04d",num[i]);
        puts("");
    }
    BigInt operator +(const BigInt & tmp)const {
        BigInt C;
        C.len=max(len,tmp.len);
        for(int i=0; i<C.len; i++) {
            C.num[i]+=num[i]+tmp.num[i];
            if(C.num[i]>=10000) {
                C.num[i+1]+=1;
                C.num[i]-=10000;
            }
        }
        if(C.num[C.len]>0)C.len++;
        return C;
    }
    BigInt operator * (const BigInt &tmp)const {
        BigInt C;
        for(int i=0; i<len; i++)
            for(int j=0; j<tmp.len; j++) {
                C.num[i+j]+=num[i]*tmp.num[j];
                if(C.num[i+j]>=10000) {
                    C.num[i+j+1]+=C.num[i+j]/10000;
                    C.num[i+j]%=10000;
                }
            }
        C.len=len+tmp.len-1;
        if(C.num[C.len]>0)C.len++;
        while(C.len>=2&C.num[C.len-1]==0)C.len--;
        return C;
    }
    bool operator < (const BigInt &tmp)const {
        if(len!=tmp.len)return len<tmp.len;
        for(int i=len-1; i>=0; i--) {
            if(num[i]!=tmp.num[i]) {
                return num[i]<tmp.num[i];
            }
        }
    }
};

注意 get(） 只能只能赋一个很小的值（赋值语句太麻烦了-_-||)

YANGHONG_WA
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++高精度模板
03-05
支持（无限）高精度加、减、乘、除、模、大于、小于、大于等于、小于等于、位移、等于、不等于、++、--，cin>>，cout 总之，一切int类型的运算都支持
C++高精度模板（加减乘除模）
02-04
C++竞赛高精度模板 优点：包含四则运算 抛弃传统数组，使用vector 缺点：乘法没有使用FFT算法，复杂度O(N^2) 在某些编辑器上可能无法使用资源中定义的常量，需要手动创建（CE的话可能是这个问题） 没有运算符...
高精度模板总结
正在学算法的小朋友的博客
05-27 705
简要： 以下是我对高精度模板的总结，只有乘法和加法用了底层原理，底层原理是用c++来实现的，其余的采用的是stl方法，都是用Java来实现的。 高精度加法1： import java.util.*; import java.math.*; public class Main { public static void main(String[] args){ String t1; String t2; Scanner scan = new S
高精度模板——C++实现
xiji333的博客
10-17 1430
文章目录综述朴素想法压位模板 综述 最近闲来无事写了一个比较简单的高精度模板……想来之前没有总结过这一块的知识，就写一篇博客来简单记录一下吧。关于高精度模板的资料其实挺多的，有某个方法不是很理解的话可以再搜搜资料或者自己手动模拟一下。这个模板的效率肯定不是最好的，可能还会有隐藏的bug，仅给大家提供一种实现高精度的思路。 朴素想法 我们先从最简单的开始，如果让你实现一个正数的高精度加法，你会怎么做？大部分人的做法肯定是用数组或者链表来模拟这个过程，以数组为例，从低位到高位依次存储数字的每一位，那么加法无非就
高精度模板合集与优化（全）
qq_34771124的博客
11-21 908
高精度模板合集（无注释版） 我把所有的高精度模板总结了一下，收录在这里，希望对大家有帮助。 目录 1.高精度加法 2.高精度减法 3.高精度乘法 4.高精度除法 （1）高精度除以低精度 （2）高精度除以高精度 5.高精度算法的优化思路 一、高精度加法 #include<bits/stdc++.h> using namespace std; #define N 10000000 int t1[N], t2[N], c[N]; char a[N], b[N];// 两个加数 int main(){
【算法模板】高精度模板（带图详解）
Z1tai的博客
11-04 1420
高精度模板（加减乘除）
【C++】高精度模板大整合！高精度模板看这篇真的就够了
Sharon_zhugecat的博客
09-30 3369
高精度整合模板！学高精度这一篇够了！高精度的四则运算与取模、高精度与低精度的四则运算、取模和开根，以及浮点高精度！
高精度乘以高精度模板
骑鱼的喵喵的博客
02-24 1043
高精度乘法：高精度乘以高精度 题目描述  高精度乘法。输入两个正整数，求它们的积。 输入     两行，每行为一个高精度整数，长度不超过255。 输出     一行，相乘的结果。 做题一定要注意边界情况。 #include&lt;stdio.h&gt; #include&lt;string.h&gt; using namespace std; char str1[265]; c...
高精度模板 - 加、减、乘、除法(C++实现)
njuptACMcxk的博客
03-28 668
高精度模板 - 加、减、乘、除法(C++实现) 四个模板均是基于正整数之间的操作，若出现负数，可以通过符号的添加来转化到正整数上来。四个模板均是基于正整数之间的操作，若出现负数，可以通过符号的添加来转化到正整数上来。四个模板均是基于正整数之间的操作，若出现负数，可以通过符号的添加来转化到正整数上来。 一、高精度加法： 数组A和数组B按照低位在前，高位在后，将两个大数存储起来。(原因是在数组的末尾添...
信息学奥赛第六节 —— 高精度模板(高精度加法、减法乘法)
smallrain6的博客
04-15 1922
高精度算法出现的原因 当参与运算的数的范围大大的超出了标准数据类型，如int（-2147483648 ~ 2147483647）或者long long的范围，就需要使用高精度算法来进行数的运算。高精度运算的特点是代码长度比较长，本质是对数学运算过程的模拟。既然不能使用标准数据类型，所以考虑使用字符串或者数组来存储这类大数据。 常用的一些最大值符号 0x7f7f7f7f —— 比int的最大值小一点 0x3f3f3f3f —— 比int的最大值的一半小一点 INT_MAX —— int的最大值 #incl
高精度模板 c++实现
08-11
高精度c++模板，实测没有问题，可以放心使用，常数一般，代码可移植性和封装性较好
2024年公关服务行业分析报告.pptx
07-09
行业报告
惠州市建筑物矢量数据（Shp格式+带高度）.txt
最新发布
07-09
因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。
Matlab语言教程及案例
07-09
项目总结 本文详细介绍了Matlab的基础知识和一个完整的数据分析与可视化案例。内容包括： 1. **基本操作**：基本算术运算和矩阵操作。 2. **绘图**：二维和三维绘图。 3. **函数和脚本**：编写和运行Matlab函数和脚本。 4. **案例分析**：生成模拟数据，进行数据预处理、绘图和统计分析。 通过这个项目，读者可以掌握Matlab的基本使用方法，并了解如何在Matlab中进行数据分析和可视化。这对于初学者入门Matlab编程、提升数据处理和分析能力非常有帮助。希望本文能为读者提供有价值的参考，提升其Matlab编程和数据分析技能。
KB8825英文数据手册
07-09
三星KB8825英文数据手册
述职报告（08）PPT模板.pptx
07-09
述职报告（08）PPT模板.pptx
高精度与高精度间的模板
07-27
- *1* *2* *3* [信息学奥赛第六节 —— 高精度模板(高精度加法、减法乘法)](https://blog.csdn.net/smallrain6/article/details/124188182)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值