高精度压位

最新推荐文章于 2021-11-24 13:04:01 发布
最新推荐文章于 2021-11-24 13:04:01 发布
阅读量155 收藏
点赞数
原文链接：http://www.cnblogs.com/perisino/p/10335145.html
版权

压位的原因

正常的高精度计算中，每一位只存了一位数字，可是当面对比较大的计算的时候呢，如果说每一位都只存一位数字，那么计算的时间就会比较地长。这个时候可以通过每一位高精度中存储多位数字的方法来降低运算的时间

例题引入

简单的来说就是 一个高精度的开根号，只要求开到整数向下取整就可以了。数据范围是10^1000;
首先就是开高精度根号的方法，很容易想到的方法就是二分或者是手动开根号。我这里使用的是二分的方法。
这一道题最开始我是直接高精度来的,然后TLE了，接着我压了四位，还是TLE了，然后直接10000000一位了，终于A了。
那么接下来我来一点点解析代码(实际上我只解析读入而已了)

inline void input(){ // 读入  
        char S[maxn];
        scanf("%s",S);
        memset(val,0,sizeof(val));
        int lenS=strlen(S); 
        int j=0;
        for(int i=lenS-1;i>=0;i-=7){//因为是10^8的进制，所以给7位
            int t=max(i-6,0),res=0;//i-6~i一共七位，
            while(t<=i){
                res=res*10+S[t]-'0';
                t++;
            }
            val[++j]=res;
        }
        val[0]=j;
    }

我的解析全写注释了，实际上总共我也只有两句解析，因为我在这两个地方没怎么注意，所以最开始我……
至于这一个高精度的其他部分，那么就直接把10改成对应的大小就可以了，我这里是10^8

#include<bits/stdc++.h>
#define Int64 long long
#define carries 10000000
#define maxn 1003
using namespace std;
struct largenum{  
    Int64 val[maxn];
    Int64 operator [](const int &ref)const{
        return val[ref];
    }
    
    inline void input(){ // 读入  
        char S[maxn];
        scanf("%s",S);
        memset(val,0,sizeof(val));
        int lenS=strlen(S); 
        int j=0;
        for(int i=lenS-1;i>=0;i-=7){
            int t=max(i-6,0),res=0;
            while(t<=i){
                res=res*10+S[t]-'0';
                t++;
            }
            val[++j]=res;
        }
        val[0]=j;
    }
    
    /*inline void StrIn(char *S){
        memset(val,0,sizeof(val));
        int lenS=strlen(S);
        val[0]=lenS;
        for(int i=lenS-1,j=1;i>=0;i--,j++) val[j]=S[i]-'0';
    }*/
    
    inline void output(){ // 输出  
        printf("%ld",val[val[0]]);
        for(int i=val[0]-1;i>=1;i--)
         printf("%07ld",val[i]); 
    }
    
    bool operator ==(const largenum &obj)const{ // 判断是否等于  
        if(val[0]!=obj[0]) return false;
        for(int i=1;i<=val[0];i++) if(val[i]!=obj[i]) return false;
        return true;
    }
    
    bool operator <(const largenum &obj)const{ // 判断是否小于   
        if(val[0]>obj[0]) return false;
        if((*this)==obj) return false;
        if(val[0]<obj[0]) return true;
        for(int i=val[0];i>=1;i--){
            if(val[i]>obj[i]) return false;
            if(val[i]<obj[i]) return true;
        }
        return true;
    }
    
    bool operator >(const largenum &obj)const{ // 判断是否大于   
        largenum cmp=*this;
        if(cmp < obj || cmp == obj) return false;
        return true;
    }
    
    largenum operator +(const largenum &obj)const{ // 加法运算  
        largenum cmp;
        memset(cmp.val,0,sizeof(cmp.val));
        Int64 pos=max(val[0],obj.val[0]),add=0;
        for(int i=1;i<=pos;i++){
            cmp.val[i]=val[i]+obj[i]+add;
            add=cmp.val[i]/carries;
            cmp.val[i]=cmp.val[i]%carries;
        }
        if(add>0) cmp.val[++pos]=add;
        cmp.val[0]=pos;
        return cmp;
    }
    
    largenum operator -(const largenum &obj)const{ // 减法运算 只能减出正数  
        largenum cmp;
        memset(cmp.val,0,sizeof(cmp.val));
        Int64 pos=val[0],rent=0; // rent 借位  
        for(int i=1;i<=pos;i++){
            cmp.val[i]=val[i]-obj[i]-rent;
            if(cmp.val[i]<0) {cmp.val[i]+=carries;rent=1;}
            else rent=0;
        }
        while(cmp.val[pos]==0 && pos>1) pos--;
        cmp.val[0]=pos;
        return cmp;
    }
    
    largenum operator *(const int &obj)const{ // 高精度 ×低精度 
        
        largenum cmp;
        memset(cmp.val,0,sizeof(cmp.val));
        Int64 pos=val[0]; // 进位 
        long long add=0;
        for(int i=1;i<=pos;i++){
            cmp.val[i]=val[i]*obj+add;
            add=cmp.val[i]/carries;
            cmp.val[i]=cmp.val[i]%carries;
        }
        while(add>0){
            cmp.val[++pos]=add%carries;
            add/=carries;
        }
        while(cmp.val[pos]==0 && pos>1) pos--;
        cmp.val[0]=pos;
        return cmp;
    }
    
    largenum operator *(const largenum &obj)const{ // 高精度 ×高精度 
        // 对于高精度数 a 和高精度 b   
        // 这个算法不能写成 a=a*b 
        largenum cmp;
        memset(cmp.val,0,sizeof(cmp.val));
        Int64 pos=val[0]+obj[0];
        for(int i=1;i<=val[0];i++){
            for(int j=1;j<=obj[0];j++){
                cmp.val[i+j-1]+=val[i]*obj[j];
                cmp.val[i+j]+=cmp.val[i+j-1]/carries;
                cmp.val[i+j-1]=cmp.val[i+j-1]%carries;
            }
        }
        while(cmp.val[pos]==0 && pos>1) pos--;
        cmp.val[0]=pos;
        return cmp;
    }
    
    largenum operator /(const int &obj)const{ // 高精度 ÷低精度  
        largenum cmp;
        memset(cmp.val,0,sizeof(cmp.val));
        Int64 pos=val[0],div=0;
        for(int i=pos;i>=1;i--){
            cmp.val[i]=(div*carries+val[i])/obj;
            div=(div*carries+val[i])%obj;
        }
        while(cmp[pos]==0 && pos>1) pos--;
        cmp.val[0]=pos;
        return cmp;
    }
    
    int operator %(const int &obj)const{ // 高精度 % 低精度  
        int pos=val[0],div=0;
        for(int i=pos;i>=1;i--) div=(div*carries+val[i])%obj;
        return div;
    }
    
    largenum operator /(const largenum &obj)const{ // 高精度 ÷高精度  
        largenum cmp,t_cmp;
        memset(cmp.val,0,sizeof(cmp.val));
        memset(t_cmp.val,0,sizeof(t_cmp.val));
        Int64 pos=val[0];
        cmp.val[0]=1;cmp.val[1]=0;
        t_cmp=cmp;
        if((*this)<obj) return cmp; // 小于除数直接返回 0  
        for(int i=pos;i>=1;i--){
            t_cmp=t_cmp*carries;
            t_cmp.val[1]=val[i];
            int k=0;
            while(t_cmp>obj || t_cmp==obj)
            {
                t_cmp=t_cmp-obj;
                k++;
            }
            cmp.val[i]=k;
        }
        while(cmp.val[pos]==0 && pos>1) pos--;
        cmp.val[0]=pos;
        return cmp;
    }
    
    largenum operator %(const largenum &obj)const{ // 高精度 % 高精度  
        largenum t_cmp;
        memset(t_cmp.val,0,sizeof(t_cmp.val));
        Int64 pos=val[0];
        t_cmp.val[0]=1;t_cmp.val[1]=0;
        if((*this)<obj) return (*this); // 小于除数直接返回本身 
        for(int i=pos;i>=1;i--){
            t_cmp=t_cmp*carries;
            t_cmp.val[1]=val[i];
            while(t_cmp>obj || t_cmp==obj) t_cmp=t_cmp-obj;
        }
        return t_cmp;
    }
    void lgnsqrt(){
        largenum one={{1,1}};
        largenum l={{1,1}};
        largenum r=*this;
        largenum cmp=*this;
        largenum mid=(l+r)/2;
        largenum tmp=mid*mid;
        while(l<r){
            if(tmp<cmp||tmp==cmp){
                l=mid+one;
            }
            else r=mid;
            mid=(l+r)/2;
            tmp=mid*mid;
        }
        if(mid*mid>cmp&&((mid-one)*(mid-one)<cmp||(mid-one)*(mid-one)==cmp))
            mid=mid-one;
        for(int i=0;i<=mid.val[0];i++){
            val[i]=mid.val[i];
        }
    }

在这一段高精度的最后是自己写的二分开方这里就按正常的开方来就可以了，因为是向下取整，所以呢我就在在后面加了一个if语句。
那么，That's all.

转载于:https://www.cnblogs.com/perisino/p/10335145.html

weixin_30839881
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
高精度算法-压位
LiuKairui的博客
07-31 5696
我们之前做过大整数类的运算的题目 大整数乘法 大整数加法 这个方法看似是无敌的，，， 但是那么如果是一个10000^10000位的数据呢？ 数组根本开不到这么大的。。。 有这样的题目吗？ 传送门 这时候我们就需要压位了。。。 还记得我们存储数字的方式？ 举个栗子:1234 + 1234这是之前的存储方式 实际上我们一个数组空间(int)是可以储存 2147483647 以...
（压位）高精度思想教程 与 代码实现
IcEternal
07-23 5500
高精度这玩意儿真是好久没写了，时隔多年，从 Pascal 转到 C++ , 代码风格也变了 重新编了一下（经过潘神指导！），觉得比以前写的好多了~ 想了想干脆写一个小教程，希望初学者能有所收获~~ 一.高精度四则运算思想 高精度这个东西其实谁都会，上过小学数学课就知道高精度怎么做了，就是按照人的运算方式，一位一位运算。 1.加法  就是 从个位开始 两个数字相加，如
【算法专题】高精度之压位
weixin_42638946的博客
11-14 3270
高精度之压位 当数据过大时，此时long long存储不下，因此需要使用vector或者数组存储，然后计算。 一般vector或者数组中每个数据都是一个int，如果每个位置只是存储0~9一位数字的话，比较浪费空间，并且计算也会变慢。因此可以让每个位置存储连续的多位数字，这被称作压位。 这里以压4位为例，也就是说：vector或者数组中每个位置存储四个连续的数字。 1. 基本高精度运算 关于基本高精度计算可以参考：高精度运算 2. 高精度压位运算 压位和不压位的高精度计算存在三点不同点（以下提到的压
压位高精度
ankong9844的博客
02-23 368
前言 本文的所有代码用C++实现，若在代码段里发现未定义的行为，请到最后的完整代码里寻找该行为含义。若有错误敬请在评论区指正。谢谢您的阅读。 引入 普通高精度每一位存一个数字，可是对于一个int型的存储空间，可存的最大数值为2147483647，只存一个数字是极大的空间浪费。因此，为了在节约空间的同时减少时间复杂度，我们尽量在一个空间中多存几位数字。对于乘法，两数之积的位数最大可达...
高精度类（压位）C++实现
06-03
高精度压位 #include #include #include using namespace std; const int maxleng=500; class BigInt { private: int leng; int num[maxleng]; public:
压位高精度模板，支持负数
04-25
自己写的压位高精度支持负数，保证无bug，单精高精运算时不会像其他人一样偷懒直接类型转换再运算，会很慢，可以+-*/%以及快速幂，压位大小可以自己改(不过输出流重载的地方也要改一下)
C++ （压位）高精度四则运算
07-23
写的比较漂亮的一个高精度四则运算 压位只需改两个const即可~非常方便
C++ 高精度封装模板
08-27
此模板为已封装模板，包含 高精度的+，-，*，/，不包含小数 by LAZ
高精度模板
11-16
高精度模板，整合了多篇文档，有高精度加法，高精度减法，高精度乘法，高精度除法，高精度取模法等模板...
高精度计算（+-*/）（压位计算）（c++实现）
weixin_60257971的博客
11-24 935
进来的时候如果没看见除法，说明我也还不会，会了的话我会补充上去的。如果要看的除法的，得去看别人的了。 目录 初始化： 加法： 减法： 乘法： 输出：这个是重点！！！！！！！！！！！ 完整代码： 如果你是从我的“P1601 A+B Problem（高精）”这篇文章来的话，可以看一下压位计算，更加的快捷方便。 高精度计算就是因为超过了数据表达的类型，从用其他的方式来进行计算。 压位就是说将一长串的数字分割开来，来单独进行保存，从而不会发生超过范围。 初始化： 可以看到 k 其...
高精度——压位的思想及应用
frankchenfu的博客
12-31 2473
这里我们简单介绍一下高精度的计算。 我们都知道在Cpp/C/Pas等语言中，整数最大能储存\(2^{64} -1\)，超过这个范围就表示不了了（不包括个别支持int128的编译器）。这个时候，我们如果希望把这些整数存储下来，就需要用到高精度的算法和思想。高精度就是像小学学过的竖式运算一样的（除法除外）。然后就直接模拟即可。除法一位一位地试商即可。 接下来我们发现就是一位一位地加减很慢，我们考虑如何...
高精度压位1
WendyCasr的博客
03-19 296
#include<cstdio> #include<cstring> #include<iostream> using namespace std; struct sd { int lend,d[300]; }; void readit(sd &c) { char st[300],st1[300];scanf("%s",st); int k=strlen(st),k1;
高精度计算(三)压位
热门推荐
sSay
08-03 1万+
压位高精
压位高精度模板
哇哈哈的专栏
12-06 1915
原先是整型数组每个元素存1个数字，压位高精是每位存8个数字，这样可以加速8呗，空间也减小了。可谓是对整形数组的充分利用。 #include #include #include #include #include #include #include #include #include #include #include #include #include #define LL long long
高精度压位模版
竹摇清影照幽窗
04-19 456
文章目录高精度加法高精度减法高精度乘法整合练习luogu1255luogu1604 高精度加法 /*************************************** User:Mandy.H.Y Language:c++ Problem:luogu1601 A+B Problem（压位） Algorhithm:High Precision Addition **************...
高精度算法中的压位啥意思
最新发布
07-17
在高精度算法中，"压位"是指将多位数的每一位存储在一个数据结构中，例如数组或向量的每个元素。通过这种方式，可以实现对大整数进行计算和操作。 通常情况下，我们使用整型变量来表示一个数的每一位。例如，对于一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值