我的挫13大数模板

最新推荐文章于 2022-02-25 19:38:17 发布
原创 最新推荐文章于 2022-02-25 19:38:17 发布 · 411 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c #fft

本文详细介绍了一种大数运算的实现方式，包括大数的加减乘除、比较及输入输出等功能，并提供了具体的应用实例，如解决HDU1002等编程题。

X

struct Bignum{
#define VV 10010
#define CONT int
#define WID 10000
    private:
        CONT bit[VV];
        int bitlen;
        bool flag;
    public:
        int getlen(){
            return bitlen;
        }
        CONT getpw(int x){
            switch (x)
            {
                case 0:return (CONT)1;
                case 1:return (CONT)10;
                case 2:return (CONT)100;
                case 3:return (CONT)1000;
                case 4:return (CONT)10000;
                case 5:return (CONT)100000;
                case 6:return (CONT)1000000;
                case 7:return (CONT)10000000;
                case 8:return (CONT)100000000;
                case 9:return (CONT)1000000000;
                default :return (CONT)-1;
            }
        }
        Bignum(){ bitlen=1; bit[0]=0; flag=false;}
        ~Bignum(){}
        Bignum(CONT x){
            if(x<0) flag=true,x=-x;
            else flag=false;
            bitlen=0;
            if(!x) bit[bitlen++]=0;
            while(x){
                bit[bitlen++]=x%WID;
                x/=WID;
            }
        }
        Bignum(char str[]){
            const int wid=(int)sizeof(CONT);
            int end;
            if(str[0]=='-'){ end=1; flag=true; }else { end=0; flag=false; }
            int i;
            CONT mid=0,p=0;
            for(i=0;str[i];i++);--i;
            for(bitlen=0;i>=end;i--){
                mid+=getpw(p)*(str[i]-'0'); p++;
                if(p>=wid){ bit[bitlen++]=mid; p=0; mid=0; }
            }
            if(mid)bit[bitlen++]=mid;
            for(i=bitlen-1;i>0&&!bit[i];i--); bitlen=i+1;
            if(flag&&bitlen==1&&bit[0]==0)flag=false;
        }
        void sprint(CONT x){
            if(x<0) flag=true,x=-x;
            else flag=false;
            bitlen=0;
            if(!x) bit[bitlen++]=0;
            while(x){
                bit[bitlen++]=x%WID;
                x/=WID;
            }
        }
        void sprint(char str[]){
            const int wid=(int)sizeof(CONT);
            int end;
            if(str[0]=='-'){ end=1; flag=true; }else { end=0; flag=false; }
            int i;
            CONT mid=0,p=0;
            for(i=0;str[i];i++);--i;
            for(bitlen=0;i>=end;i--){
                mid+=getpw(p)*(str[i]-'0'); p++;
                if(p>=wid){ bit[bitlen++]=mid; p=0; mid=0; }
            }
            if(mid)bit[bitlen++]=mid;
            for(i=bitlen-1;i>0&&!bit[i];i--); bitlen=i+1;
            if(flag&&bitlen==1&&bit[0]==0)flag=false;
        }
        bool scan(){
            char str[VV*((int)sizeof(CONT))+1];
            int ret=scanf("%s",str);
            sprint(str);
            return ret!=-1;
        }
        void print(){
            const int wid=(int)sizeof(CONT);
            if(flag)  putchar('-');
            if(wid==(int)sizeof(int)){
                printf("%d",bit[bitlen-1]);
                for(int i=bitlen-2;i>=0;i--) printf("%04d",bit[i]);
            }
            else{
                printf("%I64d",bit[bitlen-1]);
                for(int i=bitlen-2;i>=0;i--) printf("%08I64d",bit[i]);
            }
        }
        friend istream& operator>>(istream &in,Bignum &b){
            char str[VV*((int)sizeof(CONT))+1];
            in>>str;
            b.sprint(str);
            return in;
        }
        friend ostream& operator<<(ostream &out,Bignum b){
            out<<b.bit[b.bitlen-1];
            for(int i=b.bitlen-2;i>=0;i--){
                out.width((int)sizeof(CONT));
                out.fill('0');
                out<<b.bit[i];
            }
            return out;
        }
        void zero(){ for(int i=0;i<VV;i++)bit[i]=0; bitlen=1; bit[0]=0; flag=false; }
        bool ZERO(){ return (bitlen==1&&bit[0]==0); }
        bool odd(){ return bit[0]&1; }
        void negation(){
            flag=!flag;
            if(flag&&bitlen==1&&bit[0]==0)flag=false;
        }
        void abs(){ if(flag)flag=false; }
        void details(char *str = "num"){
            printf("[%s->bitlen = %d]\n[%s->flag = %d]\n",str,bitlen,str,flag);
        }
        friend bool operator==(Bignum &a,Bignum &b){
            if(a.flag!=b.flag||a.bitlen!=b.bitlen) return false;
            for(int i=a.bitlen-1;i>=0;i--) if(a.bit[i]!=b.bit[i]) return false;
            return true;
        }
        friend bool operator!=(Bignum &a,Bignum &b){ return !(a==b); }
        friend bool operator==(Bignum &a,CONT &b){ Bignum c(b); return a==c; }
        friend bool operator==(CONT &a,Bignum &b){ return b==a; }
        friend bool operator!=(Bignum &a,CONT &b){ Bignum c(b); return a!=c; }
        friend bool operator!=(CONT &a,Bignum &b){ return b!=a; }
        friend bool operator>(Bignum &a,Bignum &b){
            if(a.flag==b.flag){
                if(a.bitlen==b.bitlen){
                    if(a.flag){
                        for(int i=a.bitlen-1;i>=0;i--)
                            if(a.bit[i]!=b.bit[i]) return a.bit[i]<b.bit[i];
                    }
                    else{
                        for(int i=a.bitlen-1;i>=0;i--)
                            if(a.bit[i]!=b.bit[i]) return a.bit[i]>b.bit[i];
                    }
                    return false;
                }
                if(a.flag) return a.bitlen<b.bitlen;
                return a.bitlen>b.bitlen;
            }
            return b.flag;
        }
        friend bool operator>(Bignum &a,CONT &b){ Bignum c(b); return a>c; }
        friend bool operator>(CONT &a,Bignum &b){ Bignum c(a); return c>b; }
        friend bool operator<(Bignum &a,Bignum &b){ return b>a; }
        friend bool operator<(Bignum &a,CONT &b){ Bignum c(b); return a<c; }
        friend bool operator<(CONT &a,Bignum &b){ Bignum c(a); return c<b; }
        friend bool operator>=(Bignum &a,Bignum &b){ return (a>b||a==b); }
        friend bool operator>=(Bignum &a,CONT &b){ Bignum c(b); return a>=c; }
        friend bool operator>=(CONT &a,Bignum &b){ Bignum c(a); return c>=b; }
        friend bool operator<=(Bignum &a,Bignum &b){ return (a<b||a==b); }
        friend bool operator<=(Bignum &a,CONT &b){ Bignum c(b); return a<=c; }
        friend bool operator<=(CONT &a,Bignum &b){ Bignum c(a); return c<=b; }
        friend Bignum operator-(Bignum &a){
            Bignum c=a; c.flag=!c.flag;
            if(c.flag&&c.bitlen==1&&c.bit[0]==0)c.flag=false;
            return c;
        }
        friend Bignum operator+(Bignum a,Bignum b){
            Bignum ans((CONT)0);
            if(a.ZERO()) return b; if(b.ZERO()) return a;
            if(a.flag==b.flag){
                ans.flag=a.flag;
                int len=a.bitlen; if(b.bitlen>len) len=b.bitlen;
                ans.bitlen=len;
                int c=0;
                for(int i=0;i<len;i++){
                    if(i>=a.bitlen){
                        ans.bit[i]=b.bit[i]+c; c=ans.bit[i]/WID; if(ans.bit[i]>=WID) ans.bit[i]%=WID;
                        continue;
                    }
                    else if(i>=b.bitlen){
                        ans.bit[i]=a.bit[i]+c; c=ans.bit[i]/WID; if(ans.bit[i]>=WID) ans.bit[i]%=WID;
                        continue;
                    }
                    else {
                        ans.bit[i]=a.bit[i]+b.bit[i]+c; c=ans.bit[i]/WID; if(ans.bit[i]>=WID) ans.bit[i]%=WID;
                    }
                }
                if(c) ans.bit[len++]=c;
                ans.bitlen=len;
                return ans;
            }
            else{
                if(a.flag){
                    a.abs();
                    if(a>b) ans.flag=true;
                    else { ans=a; a=b; b=ans; ans.flag=false; }
                }
                else{
                    b.abs();
                    if(a>b) ans.flag=false;
                    else { ans=a; a=b; b=ans; ans.flag=true; }
                }
                int len=a.bitlen;
                for(int i=0;i<len;i++){
                    if(i>=b.bitlen){
                        ans.bit[i]=a.bit[i];
                        continue;
                    }
                    if(a.bit[i]<b.bit[i]){
                        a.bit[i]+=WID;
                        a.bit[i+1]-=1;
                    }
                    ans.bit[i]=a.bit[i]-b.bit[i];
                }
                for(len=len-1;len>0&&ans.bit[len]==0;len--);
                ans.bitlen=len+1;
                return ans;
            }
        }
        friend Bignum operator-(Bignum &a,Bignum b){
            b.negation();
            return a+b;
        }
        friend Bignum operator/(Bignum &a,CONT b){
            Bignum ans;
            if((a.flag&&b<0)||(!a.flag&&b>=0))ans.flag=false;
            else ans.flag=true;
            if(b<0)b=-b;
            CONT c=0;
            for(int i=a.bitlen-1;i>=0;i--){
                c=c*WID+a.bit[i];
                ans.bit[i]=c/b;
                if(c>=b)
                    c%=b;
            }
            int len;
            for(len=a.bitlen-1;len>0&&ans.bit[len]==0;len--);
            ans.bitlen=len+1;
            return ans;
        }
        friend Bignum operator*(Bignum &a,Bignum &b){
            Bignum ans;
            if(a.ZERO()||b.ZERO()) return ans;
            if(a.flag==b.flag) ans.flag=false;
            else ans.flag=true;
            ans.bitlen=a.bitlen+b.bitlen;
            for(int i=0;i<ans.bitlen;i++)ans.bit[i]=0;
            for(int i=0;i<a.bitlen;i++){
                for(int j=0;j<b.bitlen;j++){
                    int k=i+j;
                    ans.bit[k]+=a.bit[i]*b.bit[j];
                    ans.bit[k+1]+=ans.bit[k]/WID;
                    if(ans.bit[k]>=WID) ans.bit[k]%=WID;
                }
            }
            while(ans.bit[ans.bitlen-1]==0&&ans.bitlen>1) ans.bitlen--;
            return ans;
        }
        friend CONT operator%(Bignum &a,CONT b){
            int ret=1;
            if(a.flag) ret=-1;
            if(b<0) b=-b;
            CONT c=0;
            for(int i=a.bitlen-1;i>=0;i--){
                c=c*WID+a.bit[i];
                if(c>=b) c%=b;
            }
            return ret*c;
        }
        friend Bignum operator*(Bignum a,CONT b){
            if((a.flag&&b<0)||(!a.flag&&b>=0)) a.flag=false;
            else a.flag=true;
            if(b<0)b=-b;
            int c=0;
            int len=a.bitlen;
            for(int i=0;i<len;i++){
                a.bit[i]=a.bit[i]*b+c;
                c=a.bit[i]/WID;
                if(a.bit[i]>=WID) a.bit[i]%=WID;
            }
            while(c){
                a.bit[len++]=c%WID;
                c/=WID;
            }
            a.bitlen=len;
            return a;
        }
        friend Bignum operator*(CONT a,Bignum b){ return b*a; }
        friend Bignum operator+(Bignum a,CONT b){ Bignum ans(b); return a+ans; }
        friend Bignum operator+(CONT a,Bignum b){ return b+a; }
        friend Bignum operator^(Bignum a,CONT p){
            Bignum ret(1);
            for(;p;p>>=1){
                if(p&1)ret=ret*a;
                a=a*a;
            }
            return ret;
        }
};


这里大数是大整型，可以大数比较大小，输入输出流，大数乘法，大数加减法，大数的普通整型次幂，大数与普通整型取余与除法。

可以有负数。


HDU1002，HDU1042以及  http://192.168.100.16/diy/contest_show.php?cid=11954  这个DIY的1005能AC。


另外HDU1402大数乘法这个题目将VV设置到100010然后用G++也能过。只不过稍微慢了点，因为没有用FFT，FFT正在学习中，等学会了更新有FFT的版本。


1402：

int main()
{
    Bignum a,b,c;
    while(a.scan(),b.scan())
    {
        c=a*b;
        c.print();puts("");
    }
}

输入输出流： 

int main()
{
    Bignum a,b,c;
    while(cin>>a>>b)
    {
        c=a*b;
        cout<<c<<endl;
    }
}
前者953MS，后者984MS。。。。。。运气不好就超时了。。。。


外卖cps返利怎么做，我的一些实操经验分享
北风博客
04-18 5656
之前写过一篇《近期实操的“月躺赚3000块“的小项目》，很多朋友也因此关注我，不过当时用的是订阅号，引流也都采用的免费渠道，也是认知不够，小“富”即安了......就想着赚些零花钱算了，没有及时的将项目放大，相比之前，现在的获客难度和成本，简直一个天堂一个地狱。 不过就算拍断大腿也没什么卵用，正好这次生财举行外卖cps小航海，果断就参与了，一来是体会下自己和大佬的差距，二来是自己确实缺少放大项目从10-100的经验，事实证明，这又是一次正确的“投资”，特此复盘，算是对30天以来的阶段性总结。 ..
应各位朋友的要求，贴出当年写的考研经历文章，希望能再给准备考研的朋友一些启发吧
zhouaho2010的博客
10-09 728
前两天发了一篇“双非计算机专硕考博历程分享”的文章，没想到短短两天引起很多朋友的关注，首先在此深表感谢！！！好多朋友看了我的经历能对自己有所启发有所帮助，我觉得这样我的文章就写的有价值，也对我今后发博文有极大的鼓励！ 本来写这篇博文的初衷是给准备考博的硕士生朋友看的，但没想到也有本科生朋友看到了并发来私信咨询我考研经历，我就想把当年写在QQ空间里的关于“考研经历”的文章贴到这里来，希望能给准备考研...
2015山东省赛总结
I fight, so you don't have to
05-12 1559
这次是我们三个组队第一次正式上场厮杀，热身赛我们过了三个题就在测机器了，我们觉得不能锋芒毕露，测完机器看队伍排名，发现我们都记不下各队的队员是谁，只能猜看，主要看了看外校的队伍，预测了几支金牌队，事实证明预测还是比较准确的。 比赛过程：第二天正式比赛，我就和帅哥睡了个懒觉，最后三金队长靠不住了，破门而入把我们叫醒了。当然帅哥还是继续睡得，我来到机房和sx整理模板和想想跟榜的事情。最后快进赛场了，
HDU OJ ACM Steps 上的题目详细介绍
悠然见南山的博客
11-19 1540
之前在杭电 OJ 上做题，看到有 ACM Steps 这个链接，进去之后发现是一个类似于闯关的机制，可以让增加做题人的激情……据说完全通关后会有奖励，不知道是不是真的。但是里面没有题目的分类介绍，每一关只给出了题目，并没有给出相关的知识点介绍，是我太菜的缘故吧，想想大神们看了题不就能知道了吗……，但是只有做出来本关的题目后，才能查看下一关的题目，所以我到网上搜了搜看看有没有详细的介绍，结果发现有一个
HDU ACM Steps攻略 ACM Steps的全部内容
坚持不懈
03-07 1913
原地址：http://www.byywee.com/page/M0/S607/607452.html 总结了一下ACM STEPS的各章内容，趁便附上我的Steps题号（每人的不一样）。别的，此文首要目标是为了装逼；大牛请疏忽；摸索欲斗劲强的请疏忽；其实不乐于从A+B刷起的可以找到须要的响应题号操练～～1.1根蒂根基输入输出：LCY的 A+B 8题（1089~1096）1.2C说话根蒂根基：根蒂根
[kuangbin带你飞]专题十四 数论基础
weixin_30471065的博客
04-06 237
ID Origin Title 111/423 Problem A LightOJ 1370 Bi-shoe and Phi-shoe 21/74 Problem B LightOJ 1356 Prime Independence 61/332 Problem C ...
HDU分类
u011044759的专栏
04-17 879
原地址：http://www.byywee.com/page/M0/S607/607452.html 总结了一下ACM STEPS的各章内容，趁便附上我的Steps题号（每人的不一样）。 别的，此文首要目标是为了装逼； 大牛请疏忽； 摸索欲斗劲强的请疏忽； 其实不乐于从A+B刷起的可以找到须要的响应题号操练～～ 1.1 根蒂根基
ACM STEPS
黄俊东的专栏
08-08 996
1.1 根蒂根基输入输出：LCY的 A+B 8题 （1089~1096）   1.2 C说话根蒂根基：根蒂根基入门题 （2104，2088，1076，2095，1061，1170，3361，1197）   1.3 排序，贪婪： 1052 很恶心的一道贪婪题 3177 我推荐的这题貌似卡了不少人，遵守差值排序 （1236，108
HDU ACM Steps 攻略
Just Do IT
05-13 1038
HDU ACM Steps 攻略～ Admin 2011年10月14日 名人名言：未来是光明而美丽的，爱它吧，向它突进，为它工作，迎接它，尽可能地使它成为现实吧！——车尔尼雪夫斯基  总结了一下ACM STEPS的各章内容，趁便附上我的Steps题号（每人的不一样）。 别的，此文首要目标是为了装逼； 大牛请疏忽； 摸索欲斗劲强的请疏忽； 其实不乐于从A+
c++大数模板
03-23
c++大数模板 内含各种大数操作 还可以自己设置数的长度
C++大数模板(推荐)
09-05
C++大数模板是用于处理超出普通整型变量范围的大整数的一种编程技巧。在C++中，标准库并未提供内置的大数类型，因此需要自定义数据结构和运算方法来实现大数运算。本篇文章主要介绍了如何使用C++通过运算符重载来...
java大数模板
03-27
还在为ACM的大数高精度困扰吗？赶快用java的大数类吧！
ACM大数模板(c/c++)
07-20
ACM中的常用高精度模板，内容：大数加法，大数乘小数，大数乘大数，大数除法。
C++大数模板
07-15
大数的加减乘除，C++，C语言
K8s 很难么？带你从头到尾捋一遍，不信你学不会
热门推荐
民工哥的博客
02-23 1万+
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 4303
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 7647
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 2157
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
清除浮动的五种方法
weixin_52212950的博客
02-22 3203
为什么要清除浮动？因为往往浮动后的子元素因为脱离了标准流，不能自动撑起父元素的高度，所以会对后续布局产生影响，对此清除浮动不如理解为清除浮动产生的影响更为合理。 例如：我们设置了两个盒子如图所示，粉色为父盒子，只有宽度没有高度，蓝色盒子有宽有高，粉色盒子的高由蓝盒子的高度撑开。 但是给蓝色的子盒子设置了左浮动后，脱离了标准流，无法再撑开粉盒子，可以看到粉盒子高度变成了0； 清除浮动有五种方法： 直接设置父元素的高度 额外标签法 单伪元素法 双伪元素法 ove.
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值