高精度模板（Big_Int）

最新推荐文章于 2021-04-13 22:54:01 发布
最新推荐文章于 2021-04-13 22:54:01 发布
阅读量82 收藏
点赞数
原文链接：http://www.cnblogs.com/MaxDYF/p/9792688.html
版权

你还在为刷题时看到的高精度预警而苦恼吗？

你还在因为高精度难写而放弃宝贵的分数吗？

不用担心！让高精度模板 来帮助你！

目前已知bug：

长度最大值只能开到54724，超过这个值会爆炸（无法调试），目前原因未知

2018.09.07更新：

1、优化了高精乘以低精的速度。
2、输出优化，可使用.output()函数输出。（基于输出挂）@Jesse666
ps:那个长度最大值的bug有可能是栈空间的问题，可以试试更改栈空间有没有效果

2018.09.01更新：

1、鉴于@Jesse666同学的建议，本次更新增加了基于牛顿迭代法的高精度开平方运算。
2、我还没有掌握好关于迭代次数的问题，所以在超大整数（过100位）可能会出现精度不正确的bug，请见谅。
3、目前迭代次数为长度length*10，有更好的迭代次数计算方法可以在我的blog下留言。

ps：下面那个更新实际上是8.31晚上11点更新的，然而更新完已经9.1了，所以标号为9.1。

pps：潜在bug：该高精度模板长度最大值只能设置为54724（或者更少），目前还没有找到明确原因，有人知道的可以私信我。

2018.09.01更新：

1、更改了代码顺序，并调整了格式，阅读代码以及调试代码更加方便。
2、四则运算现在可以参与int类型（即可以Big_Int+int。
3、完善了四则运算的+=、-=等操作。

2018.08.31更新：
在集训的最后一天，我学会了高精度除法，所以顺便做出来了除法的模板。本次更新内容：

1、增加++、--等递增递减运算，平均速度比+1要快。
2、增加高精度除法/运算。
3、增加高精度取模%运算。
4、增加了高精幂（请使用a.pow(b)）运算。
5、增加了基于十进制的左移<<、右移>>运算（是基于十进制，所以等于*10和/10。比乘除法快）。
6、增加了使用int与char数组初始化的功能
7、修复了清空big_int的潜在正负性bug

如果以后发现bug，还会再更新的。喜欢请点个赞哦~

链接:https://pan.baidu.com/s/1axc75pHjtxD33U6V_6HBOg 密码: p0w7

转载请注明出处及作者。

#pragma GCC optinize(3)
#pragma comment(linker, "/STACK:102400000,10240000")
#include <bits/stdc++.h>
#define LEN 35663//100001
using namespace std;
class Big_Int{
    //54724
    private:
        int a[LEN];
        int len;
        bool f,p;
    public:
        //初始化构造函数运算 
        void clear()
        {
            memset(a,0,sizeof a);
            len=1;
           f=0;
            p=0;
        }        
        Big_Int()
        {
            clear();
        }
        Big_Int(int x)
        {
            clear();
            (*this)=x;
        }
        Big_Int(const Big_Int &x)
        {
            clear();
            (*this)=x;
        }
    
    //赋值运算 
     
        Big_Int operator =(const char *ch)
        {
            len=strlen(ch);
            if(ch[0]=='-') 
            {
                f=1;len--;
                for(int i=1;i<=len;i++) a[i]=ch[len-i+1]-'0';
                return *this;
            }
            for(int i=1;i<=len;i++) a[i]=ch[len-i]-'0';
            return *this;
        }
        Big_Int operator =(const int d)
        {
            char ch[LEN];
            sprintf(ch,"%d",d);
            *this=ch;
            return *this;
        }
    
    //四则基本运算 

        Big_Int operator +(Big_Int b)
        {
            if(f==1&&b.f==0)
            {
                f=0;
                return b-(*this);
            }
            else if(f==0&&b.f==1)
            {
                b.f=0;
                return (*this)-b;
            }
            Big_Int c;
            c.clear();
            int l=max(len,b.len);
            for(int i=1;i<=l;i++)
            {
                c.a[i]+=a[i]+b.a[i];
                c.a[i+1]=c.a[i]/10;
                c.a[i]%=10;
            }
            if(c.a[l+1]) l++;
            c.len=l;
            c.f=f&&b.f;
            return c;
        }
        Big_Int operator -(Big_Int b)
        {

            if(f==1&&b.f==0)
            {
                b.f=1;
                return b+(*this);
            }
            if(f==0&&b.f==1)
            {
                b.f=0;
                return b+(*this);
            }
            if(f==1&&b.f==1)
            {
                b.f=0;
                return b+(*this); 
            }
            Big_Int c;
            c.clear();
            if((*this)<b)
            {
                swap(*this,b);
                c.f=1;
            }
            int l=max(len,b.len);
            for(int i=1;i<=l;i++)
            {
                c.a[i]+=a[i]-b.a[i];
                if(c.a[i]<0) c.a[i+1]--,c.a[i]+=10;
            }
            while(c.a[l]==0&&l>0) l--;
            if(l==0) l=1;
            c.len=l;
            return c;
        }       
        Big_Int operator *(Big_Int b)
        {
            Big_Int c;
            c.clear();
            int l=len+b.len-1;
            for(int i=1;i<=len;i++)
            {
                for(int j=1;j<=b.len;j++)
                {
                    c.a[i+j-1]+=a[i]*b.a[j];
                    c.a[i+j]+=c.a[i+j-1]/10;
                    c.a[i+j-1]%=10;
                }
            }
            while(c.a[l+1]!=0) l++;
            c.len=l;
            if((f==0&&b.f==1)||(f==1&&b.f==0)) c.f=1;
            return c;
        }       
        Big_Int operator /(Big_Int b)
        {
            if(b==0)
            {
                throw 0x7f;
            }
            Big_Int a=(*this),c,t;
            c.len=len-b.len+1;
            for(int i=c.len;i>=0;i--)
            {
                if(a==0) break;
                t.clear();
                t=b<<i;
                while(t<=a) 
                {c.a[i+1]++;a-=t;}
            }
            while(!c.a[c.len]&&c.len>0) c.len--;
            if(c.len==0) c.len=1;
            if(f==0&&b.f==1) c.f=1;
            else if(f==1&&b.f==0) c.f=1;
            return c;
        }       
        Big_Int operator %(Big_Int b)
        {
            Big_Int c=(*this)/b;
            b=b*c;
            return (*this)-b;
        }       
        
        //比较运算 
        
        bool operator <=(Big_Int b)
        {
            return ((*this)<b||(*this)==b);
        }
        bool operator >=(Big_Int b)
        {
            return ((*this)>b||(*this)==b);
        }
        bool operator <(Big_Int b)
        {
            if((*this)==b) return 0;
            if(f&&!b.f) return 1;
            else if(!f&&b.f) return 0;
            else if(f==b.f&&f==0&&len<b.len) return 1;
            else if(f==b.f&&f==0&&len>b.len) return 0;
            else if(f==b.f&&f==1&&len<b.len) return 0;
            else if(f==b.f&&f==1&&len>b.len) return 1;
            else
            {
                int flag=-1;
                for(int i=len;i>=1;i--)
                {
                    if(a[i]>b.a[i]) 
                    {
                        flag=0;
                        break;
                    }
                    else if(a[i]<b.a[i])
                    {
                        break;
                    }
                }
                if(f==1) flag=!flag;
                else if(f==-1) return 0;
                return flag;
            }
        }   
        bool operator ==(Big_Int b)
        {
            if(f!=b.f) return 0;
            if(len!=b.len) return 0;
            for(int i=len;i>=1;i--)
            {
                if(a[i]!=b.a[i]) return 0;
            }
            return 1;
        }
        bool operator !=(Big_Int b)
        {
            return !((*this)==b);
        }
        bool operator !=(int b)
        {
            return !((*this)==b);
        }
        bool operator ==(int b)
        {
            Big_Int a=b;
            return a==(*this);
        }
        bool operator >(Big_Int b)
        {
            if(!((*this)<b)&&!((*this)==b)) return 1;
            else return 0;
        }

        //递增（减）运算 

        Big_Int operator ++(int)
        {
            if(f==1&&!p) 
            {
                p=1;
                (*this)--;
                return *this;
            }
            a[1]++;
            int t=1;
            while(a[t]>9) 
            {
                a[t+1]++;
                a[t]%=10;
                t++;
            }
            while(a[len+1]) len++;
            if(len==1&&a[len]==0) f=0;
            p=0;
            return *this;
        }
        Big_Int operator --(int)
        {
            if(f==1&&!p)
            {
                (*this)++;
                p=1;
                return *this;
            }
            int t=1;
            a[t]--;
            while(a[t]<0)
            {
                a[t+1]--;
                a[t]+=10;
                t++;
            }
            while(a[len+1]) len++;
            if(len==1&&a[len]==0) f=0;
            p=0;
            return *this;
        }
        
        //四则运算扩展 
        
            //加法相关 
            
        Big_Int operator +(int b)
        {
            Big_Int c=b;
            return (*this)+c;
        }       
        void operator +=(Big_Int b)
        {
            (*this)=(*this)+b;
        }
        void operator +=(int b)
        {
            Big_Int c=b;
            (*this)=(*this)+c; 
        }
            //减法相关 
                
        Big_Int operator -(int b)
        {
            Big_Int c=b;
            return (*this)-c;
        }
        void operator -=(Big_Int b)
        {
            (*this)=(*this)-b;
        }
        void operator -=(int b)
        {
            Big_Int c=b;
            (*this)=(*this)-b;
        }       
        
            //乘法相关 
        inline Big_Int operator *(int b)
        {
            /*Big_Int c=b;
            return (*this)*c;*/
            Big_Int c;
            for(int i=1;i<=len;i++)
            {
                c.a[i]+=a[i]*b;
                c.a[i+1]=c.a[i]/10;
                c.a[i]%=10;
            }
            c.len=len;
            while(c.a[c.len+1]!=0)
            {
                c.len++;
                c.a[c.len+1]=c.a[c.len]/10;
                c.a[c.len]%=10;
            }
            return c;
        }
        void operator *=(Big_Int b)
        {
            (*this)=(*this)*b;
        }
        void operator *=(int b)
        {
            (*this)=(*this)*b;
        }
        
            //除法相关 
            
        Big_Int operator /(int b)
        {
            Big_Int c=b;
            return (*this)/c;
        }
        void operator /=(int b)
        {
            Big_Int c=b;
            (*this)=(*this)/c;          
        }       
        void operator /=(Big_Int b)
        {
            (*this)=(*this)/b;
        }
        
            //取模相关 
                
        Big_Int operator %(int b)
        {
            Big_Int c=b;
            return (*this)%c;
        }       
        void operator %=(int b)
        {
            Big_Int c=b;
            (*this)=(*this)%c;
        }
        void operator %=(Big_Int b)
        {
            (*this)=(*this)%b;
        }          
           
        //特殊运算   
        Big_Int abs()
        {
            Big_Int c=(*this);
            c.f=0;return c;
        }
        Big_Int operator <<(int b)  //基于十进制的左移，所以是等同于*10 
        {
            Big_Int c;
            for(int i=b+1;i<=len+b;i++) 
              c.a[i]=a[i-b];
            c.len=len+b;
            return c;
        }
        Big_Int operator >>(int b)
        {
            Big_Int c;
            for(int i=b+1;i<=len;i++)
            {
                c.a[i-b]=a[i];
            }
            c.len=len-b;
            return c;
        }
        Big_Int pow(Big_Int b)
        {
            Big_Int a=(*this),ans=1;
            while(b!=0)
            {
                if(b.a[1]&1) ans*=a;
                a*=a;
                b/=2;
            }
            return ans;
        }
        Big_Int pow(int b)
        {
            Big_Int a=(*this),ans=1;
            while(b!=0)
            {
                if(b&1) ans*=a;
                a*=a;
                b/=2;
            }
            return ans; 
        }
        Big_Int sqrt()
        {
            Big_Int x=(*this),a=(*this);
            for(int i=1;i<=len*10;i++) x=(x+a/x)/2;
            return x;
        }
        //转换函数 
        void output()
        {
            while(a[len]==0) --len;
            for(register int i=len;i>=1;--i) putchar(a[i]+'0');
        }
        string cpp_str()
        {
            string str;
            if(len==0)
            {
                str="0";
                return str;
            }
            if(f==1&&!(len==1&&a[1]==0)) str.push_back('-');
            for(int i=len;i>=1;i--) str.push_back(a[i]+'0');
           return str;
        }
}a;
istream& operator >>(istream &in,Big_Int &a)
{
    string str;
    in>>str;
    a=str.c_str();
    return in;
}
ostream& operator <<(ostream &out,Big_Int &a)
{
    out<<a.cpp_str();
    return out;
}
int main()
{
}

转载于:https://www.cnblogs.com/MaxDYF/p/9792688.html

weixin_30252709
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
tdd_decimal_big_int
06-20
无限长整数运算 1 目标 1 实现无限长整数加法、减法及乘法 2 实现无限长整数无括号混合运算 #2 说明 由于c、c++、java等语言中整数数据类型都是有范围的，所以希望实现理想的无限大范围的整数计算，例如： ...
高精度模板Bigint Killer
weixin_30346033的博客
05-23 59
50行内实现高精度&高精度、高精度&低精度的四则运算，并且运算模块相互独立，可以根据需求进行删减。 运算结果可以直接存储在第一个操作数中（不能是第二个），如a/=b可以直接写成div(a,b,a)，无需经过第三个变量中转，其余的运算类似。 如有错误欢迎指出。 1 #include <iostream> 2 #include <cstring>...
深入了解 BigInt
人生代码 ---- 公众号
03-19 1176
BigInt是一种特殊的数字类型，它支持任意长度的整数。创建bigint的方法是在整型文字的末尾加上n，或者调用函数bigint从字符串、数字等创建bigint。constbigint...
整数数据类型bigint
chenliang
03-01 6651
文章目录1.1 bigint说明1.2 测试环境说明1.3 加unsigned属性1.3.1 SQL模式开启严格模式1.3.2 SQL模式未开启严格模式1.4 加zerofill属性1.4.1 SQL模式开启严格模式1.4.2 SQL模式未开启严格模式1.5 不加unsigned和zerofill属性1.5.1 SQL模式开启严格模式1.5.2 SQL模式未开启严格模式 1.1 bigint说明 ...
BigInt
apeiziwei的博客
04-13 3397
BigInt 1、BigInt：它的目的是比Number数据类型支持的范围更大的整数值（表示大于2^53-1的整数）。在对大整数执行数学运算时，以任意精度表示整数的能力尤为重要，使用BigInt整数溢出将不再是问题； 2、描述方式：在一个整数字面量后面加n的方式定义一个BigInt，如10n，或者调用函数BigInt（）； 3、与Number的不同点： （1）不能用Math对象中的方法； （2）不能和任何Number实例混合运算，两者必须转换成同一种类型，在两种类型来回转换时要小心，因为BigInt变量在转
int 和bigint差别有多大？
lxw1844912514的博客
09-05 8388
https://bbs.csdn.net/wap/topics/230059600 请问在mysql中int和bigint差别有多大？在什么情况下需要用到bigint？ bigint带符号的范围是-9223372036854775808到9223372036854775807。无符号的范围是0到18446744073709551615。 int普通大小的整数。带符号的范围是...
高精度模板
DancingZ的博客
08-01 281
#include&lt;bits/stdc++.h&gt; using namespace std; struct Big{ int N; vector&lt;int&gt;vec; Big(int x=0):N(1),vec(10005,0){for(N=x?0:1;x;x/=10)vec[++N]=x%10;} Big(char *s):N(strlen(s)),vec(10005,...
C++中高精度正整数运算代码模板
Hi_KER的博客
07-10 1255
背景：C++中有时我们会遇到（unsigned）long long也表示不了的大整数，这个时候我们常常会用高精度为了简化使用过程以及模板化，我们不妨用struct或class来定义详解：框架：template&lt;int SIZE&gt;//用来限制最大表示位数 class bign(){ private://在class外不能调用 int a[SIZE],len;//高精度整数，用数...
Big_Int_Calculation.zip_Big!_big in_big int_大数运算
09-21
在“Big_Int_Calculation.zip_Big!_big in_big int_大数运算”这个压缩包中，我们很可能会找到一个用于大数运算的库，它可能提供了高效且易于使用的API，以便于开发者在项目中进行大数处理。 大数运算库的开发通常...
高精度计算器_高精度计算器_
10-03
【高精度计算器】是一种特别设计用于执行数学运算的软件工具，尤其强调在处理大数运算时保持极高精确度。在VB（Visual Basic）环境中开发的高精度计算器，利用了VB的强大编程能力，使得用户能够执行那些传统浮点运算...
java_sqr(big_int).rar_Big!_Java sqr_Java里面的sqr_java s_javasqr
09-24
标题中的"java_sqr(big_int)"暗示我们要讨论的是如何在Java中对大整数执行平方根（square root）操作。这个压缩包中的"java_sqr(big_int).txt"文件可能包含了具体的算法实现或解决方案。 在标准的Java库中，`java....
抽象精品ppt模板big_eye208
09-02
抽象精品ppt模板big_eye208
自动化纹理魔法：Maya脚本在纹理贴图中的应用
最新发布
08-19
Maya脚本主要有两种形式：MEL（Maya Embedded Language）和Python。MEL是Maya的内置脚本语言，用于自动化任务、扩展Maya的功能以及自定义用户界面。MEL脚本可以快速创建对象、精确控制对象属性，以及执行复杂的场景管理任务。MEL的语法结构与C语言接近，支持强制语法和函数语法，是一种强类型语言，但通常允许隐式声明和类型转换。 Python脚本在Maya中的应用也非常广泛，特别是在Maya 2020及以后的版本中。Python提供了一种更为现代和灵活的方式来编写脚本，可以利用Python的强大库进行复杂的数据处理和自动化任务。Python脚本可以通过`maya.cmds`模块访问Maya的命令，实现与MEL相似的功能。 在Maya中，脚本可以通过“脚本编辑器”（Script Editor）进行编写和执行，也可以保存为`.mel`或`.py`文件以便重复使用。脚本编辑器提供了MEL和Python两种语言选项，允许用户在不同语言环境下编写和测试脚本。此外，Maya还支持将Python函数注册为MEL程序，以便在需要MEL脚本的地方使用Python代码。
反弹shell的几种获取方式.docx
08-19
一、反弹shell 二、python pty 方式 三、suid提权的方式 1、 suid权限的设置 2、 找出系统中具有suid权限的命令 3、 find提权 四、sessions的使用方法
IMG_20240819_173351.jpg
08-19
IMG_20240819_173351.jpg
Wireshark安装包（内有支持win7，win10，win11）总有一个版本适合
08-19
Wireshark是一款强大的网络协议分析器，主要用于捕获和深入分析网络流量，是网络故障排查、安全审计以及网络协议学习的重要工具。64位版本的Wireshark适用于运行64位操作系统的计算机，如Windows 7和8。在这个安装包中，主要包含两个文件：Wireshark-win64-2.2.1.exe是Wireshark的64位安装程序，下载帮助.txt则可能提供有关如何下载和安装软件的指导。 1. **Wireshark的基本功能**： - **数据包捕获**：Wireshark能够实时捕获来自网络接口的数据包，包括各种协议如TCP/IP、HTTP、FTP等。 - **协议解析**：它能解析并显示数据包的详细结构，帮助用户理解网络通信过程。 - **过滤与搜索**：提供强大的过滤器语言，可以快速定位特定类型的网络流量。同时，可以搜索数据包内容，便于分析。 - **颜色编码**：根据数据包的不同特性，如异常或潜在问题，使用不同颜色高亮显示。 - **解码与重构**：能够解码多种协议，并在重组TCP流时呈现会话的完整视图。
Copley驱动器软件CME使用手册
08-19
运动控制系统使用手册
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值