高精度开平方

最新推荐文章于 2023-01-11 16:26:08 发布
最新推荐文章于 2023-01-11 16:26:08 发布
阅读量2.8k 收藏 9
点赞数 2
文章标签： 高精度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C20181220_xiang_m_y/article/details/53537914
版权

高精度开平方

时间限制: 1 Sec   内存限制: 128 MB

题目描述

输入

一个整数 N。 

输出

N 的平方根下取整。 

样例输入

 (如果复制到控制台无换行，可以先粘贴到文本编辑器，再复制)

123456789012345678901234567890

样例输出

351364182882014

提示

对于 100%的数据，0<N<=10^1000。 


      别告诉我你想枚举，这种单调性问题肯定是二分答案啊，但是要用到高精度就很呵呵了，其实思想很简单，就是道堆代码的题罢了。不多说，先上代码吧

#include<cstdio>
#include<cstring>
#define max(a,b) a>b?a:b
struct node
{
    int s[10000];
    int len;
    node(){memset(s,0,sizeof(s));len=0;}//结构体默认构造函数
    void scan()//结构体成员函数，输入
    {
        char c[10000];
        scanf("%s",c);
        int o=strlen(c);
        for(len=0;len<o;len++) s[len]=c[o-len-1]-'0';
    }
    bool operator < (node p) const//重载运算符
    {
        if(len!=p.len) return len<p.len;
        for(int i=len-1;i>=0;i--) 
            if(s[i]!=p.s[i]) return s[i]<p.s[i];
        return 0;
    }
    bool operator == (node p) const
    {
        for(int i=max(len,p.len)-1;i>=0;i--)
            if(s[i]!=p.s[i]) return 0;
        return 1;
    }
    bool operator > (node p) const
    {
        if(len!=p.len) return len>p.len;
        for(int i=len-1;i>=0;i--) 
            if(s[i]!=p.s[i]) return s[i]>p.s[i];
        return 0;
    }
    node operator + (node a)
    {
        node c;
        c.len=max(len,a.len);
        for(int i=0;i<c.len;i++)
        {
            c.s[i]+=s[i]+a.s[i];
            if(c.s[i]>9) c.s[i]-=10,c.s[i+1]++;
        }
        if(c.s[c.len]) c.len++;
        return c;
    }
    node operator / (int a)
    {
        int x=0;
        node c;
        c.len=len;
        for(int i=len-1;i>=0;i--)
        {
            c.s[i]=(s[i]+x*10)/a;
            x=s[i]%a;
        }
        if(!c.s[len-1]) c.len--;
        return c;
    }
    node operator * (node a)
    {
        node c;
        for(int i=0;i<len;i++)
            for(int j=0;j<a.len;j++)
            {
                c.s[i+j]+=s[i]*a.s[j];
                if(c.s[i+j]>9) c.s[i+j+1]+=c.s[i+j]/10,c.s[i+j]%=10;
            }
        c.len=len+a.len;
        if(!c.s[c.len-1]) c.len--;
        return c;
    }
    node operator + (int a)
    {
        s[0]+=a;
        int i=0;
        while(s[i]>9) s[i]-=10,s[i+1]++,i++;
        if(s[len]) len++;
        return *this;
    }
    node operator - (int a)
    {
        s[0]-=a;
        int i=0;
        while(s[i]<0) s[i]+=10,s[i+1]--,i++;
        if(!s[len-1]) len--;
        return *this;
    }
};
int main()
{
    node n,l,r,m,f;
    n.scan();
    l.s[0]=0,l.len=1;
    r=n;
    while(l<r)//二分答案
    {
        m=(l+r+1)/2;
        f=m*m;
        if(f==n) {l=m;break;}
        else if(f>n) r=m-1;
        else l=m;
    }
    for(int i=l.len-1;i>=0;i--)
        printf("%d",l.s[i]);
}

      好，答案是对了，但是。。。光荣的TLE了，超时无奈啊。。。log一个一千位的数。。。显然，二分我们并不能修改，但是我们可以 修改高精度运算的方式----压位处理 。

      首先，我们数组的每个空间只存了一个一位数，浪费了这大好空间，循环也要超时，so，我们可以让数组的每个空间存一个多位数，这样做的话整个数组的长度就会大大减小，循环也会变快，但是压位处理要小心，不要遗留细节之处。先给一个存4位的代码吧。（只发修改了的地方）

struct node
{
    int s[10000];
    int len;
    node(){memset(s,0,sizeof(s));len=0;}
    void scan()//输入要修改
    {
        char c[10000];
        scanf("%s",c);
        int o=strlen(c);
        for(;(len+1)*4<=o;len++)
        {
            for(int i=4;i>=1;i--)
                s[len]=s[len]*10+c[o-len*4-i]-'0';
        }
        if(o%4!=0)
        {
            for(int i=0;i<o%4;i++)
                s[len]=s[len]*10+c[i]-'0';
            len++;
        }
        //for(int i=len-1;i>=0;i--) printf("%04d",s[i]);
        //printf("\n");
    }
    node operator + (node a)
    {
        node c;
        c.len=max(len,a.len);
        for(int i=0;i<c.len;i++)
        {
            c.s[i]+=s[i]+a.s[i];
            if(c.s[i]>9999) c.s[i]-=10000,c.s[i+1]++;//9和10要变成9999和10000
        }
        if(c.s[c.len]) c.len++;
        return c;
    }
    node operator / (int a)
    {
        int x=0;
        node c;
        c.len=len;
        for(int i=len-1;i>=0;i--)
        {
            c.s[i]=(s[i]+x*10000)/a;
            x=s[i]%a;
        }
        if(!c.s[len-1]) c.len--;
        return c;
    }
    node operator * (node a)
    {
        node c;
        for(int i=0;i<len;i++)
            for(int j=0;j<a.len;j++)
            {
                c.s[i+j]+=s[i]*a.s[j];
                if(c.s[i+j]>9999) c.s[i+j+1]+=c.s[i+j]/10000,c.s[i+j]%=10000;
            }
        c.len=len+a.len;
        if(!c.s[c.len-1]) c.len--;
        return c;
    }
    node operator + (int a)
    {
        s[0]+=a;
        int i=0;
        while(s[i]>9999) s[i]-=10000,s[i+1]++,i++;
        if(s[len]) len++;
        return *this;
    }
    node operator - (int a)
    {
        s[0]-=a;
        int i=0;
        while(s[i]<0) s[i]+=10000,s[i+1]--,i++;
        if(!s[len-1]) len--;
        return *this;
    }
};
int main()
{
    printf("%d",l.s[l.len-1]);
    for(int i=l.len-2;i>=0;i--)
        printf("%04d",l.s[i]);//%04d,例如2会输出0002,12会输出0012
}

显然，这样就快多了，但是。。。1042ms.........看来我们还需要继续压位。

当压位到5位及其以上时，用乘法的中间过程可能溢出，所以需要用long long。

struct node
{
    long long s[1005];
    int len;
    node(){memset(s,0,sizeof(s));len=0;}
    void scan()
    {
        char c[1010];
        scanf("%s",c);
        int o=strlen(c);
        for(;(len+1)*5<=o;len++)
        {
            for(int i=5;i>=1;i--)
                s[len]=s[len]*10+c[o-len*5-i]-'0';
        }
        if(o%5!=0)
        {
            for(int i=0;i<o%5;i++)
                s[len]=s[len]*10+c[i]-'0';
            len++;
        }
        //for(int i=len-1;i>=0;i--) printf("%04d",s[i]);
        //printf("\n");
    }
    node operator + (node a)
    {
        node c;
        c.len=max(len,a.len);
        for(int i=0;i<c.len;i++)
        {
            c.s[i]+=s[i]+a.s[i];
            if(c.s[i]>99999) c.s[i]-=100000,c.s[i+1]++;
        }
        if(c.s[c.len]) c.len++;
        return c;
    }
    node operator / (int a)
    {
        int x=0;
        node c;
        c.len=len;
        for(int i=len-1;i>=0;i--)
        {
            c.s[i]=(s[i]+x*100000)/a;
            x=s[i]%a;
        }
        if(!c.s[len-1]) c.len--;
        return c;
    }
    node operator * (node a)
    {
        node c;
        for(int i=0;i<len;i++)
            for(int j=0;j<a.len;j++)
            {
                c.s[i+j]+=s[i]*a.s[j];
                if(c.s[i+j]>99999) c.s[i+j+1]+=c.s[i+j]/100000,c.s[i+j]%=100000;
            }
        c.len=len+a.len;
        if(!c.s[c.len-1]) c.len--;
        return c;
    }
    node operator + (int a)
    {
        s[0]+=a;
        int i=0;
        while(s[i]>99999) s[i]-=100000,s[i+1]++,i++;
        if(s[len]) len++;
        return *this;
    }
    node operator - (int a)
    {
        s[0]-=a;
        int i=0;
        while(s[i]<0) s[i]+=100000,s[i+1]--,i++;
        if(!s[len-1]) len--;
        return *this;
    }
};
int main()
{
    printf("%lld",l.s[l.len-1]);
    for(int i=l.len-2;i>=0;i--)
        printf("%05lld",l.s[i]);
}
这就是压了5位，哦，终于AC了。爽。当然，用了long long应该能压更多位，大家自己去试吧。



Master.Yi
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
整数开平方算法
03-20
一个很好的整数开平方算法，非常值得借鉴，对精度不高的算法帮助很大
高精度计算器v1.2
02-03
1.改进了迭代次数，精度一般可以达到 90多位（本人限制了数组的维数为100）， 2.改进了反正切函数的算法。 自己编写了一个大数运算程序，建立了一个大数数据类型，可以类似于c++ int 一样定义数据，并封装了四则运算、三角函数，二进制转换，指数和对数函数，开平方等运算，要建立自己的大数运算程序，只要把此类的头文件加入你程序，使用上和普通函数一样。 为了大家使用方便，用builder c++ 建立了界面，做成了一个简单的计算器。请大家在找找问题，方便改进，谢谢！ 如发现问题请联系：[email protected] 对了，这个编译的程序可以独立运行，不需要安装builder c++动态库。
求一个数的平方根，结果向下取整
06-01 447
求一个数的平方根，结果向下取整
【学校OJ】 二分答案+高精度 高精度开平方
Starlight的博客
12-22 826
题目描述 输入 一个整数 N。  输出 N 的平方根下取整。  样例输入 Copy (如果复制到控制台无换行，可以先粘贴到文本编辑器，再复制) 123456789012345678901234567890 样例输出 351364182882014 提示 对于 100%的数据，0
【ICPC模板】高精度平方根
Vanishment's Blog
02-13 175
牛顿迭代法实现 公式： 核心：求与横坐标交点 求导： 牛顿迭代公式： 特别地： 上述公式求解num的平方根。 Java代码： public static BigDecimal sqrt(BigDecimal b, BigDecimal eps) { BigDecimal crt = new BigDecimal(b.toString()); Big...
阿里巴巴2019面试题 sqrt (2)约等于 1.414，要求不用数学库，求 sqrt (2)精确到小数点后 10 位。
qq_38052208的博客
08-24 845
已知 sqrt (2)约等于 1.414，要求不用数学库，求 sqrt (2)精确到小数点后 10 位。 此题可以用二分法或牛顿迭代法来实现； 大多数人不知道牛顿迭代法，我也不知道，哈哈哈。 所以我用的二分法来解决这个问题，但这道题有一个坑，那就是要考虑java中double类型数据运算时会出现精度缺失问题，网上大部分实现代码都没有考虑到这个问题，所以运行出来的程序得不到正确结果； 先放上实现代码...
求一个数的平方根（向下取整）
apple_59012575的博客
09-19 691
#include <stdio.h> int test(int n) { if (n <= 1) return n; int begin = 1; int end = n / 2; int middle; while (begin <= end) { middle = (begin + end) / 2; if (middle == n / middle) return middle; else { if (middle <
平方根
wew_king的博客
05-17 1854
#c及c++基础 title： 输入一个整数, 求它的平方根,输出答案往下取整. 比如\sqrt{5} = 2 ；sqrt{16}=4。 输入描述： 输入一个整数n (1 <= n <= 100000) 输出描述: 输出一个整数 示例1 输入 5 输出 2 题目分析：题目并不难，只是注意一些小细节（初学一定不要搞混乱了） #include<stdio.h> #include<math.h> int main() { int n; scanf("%d",&
1月8日刷题
m0_73472682的博客
01-11 277
这场比赛需要两人一队组队参加，他们不知道怎么分组。已知他们的 CrossFire 分数分别为 a, b, c, d，现在想要把他们两两分为一队，使得他们的实力比较平均，也就是两队的实力差尽量小。这里定义两队的实力差为每队的 CrossFire 分数之和的差值，现在他们想要知道这个实力差最小是多少。
记录几个开平方算法
热门推荐
编程手札
03-28 1万+
整数开平方算法: 本算法只采用移位、加减法、判断和循环实现，因为它不需要浮点运算，也不需要乘除运算，因此可以很方便地运用到各种芯片上去。 我们先来看看10进制下是如何手工计算开方的。 先看下面两个算式， x = 10*p + q  (1) 公式(1)左右平方之后得： x^2 = 100*p^2 + 20pq + q^2 (2) 现在假设我们知道x^2和p，希望求出q来，求出了
C++实现高精度计算类库
04-13
C++实现高精度计算类库，包含了FFT的乘法除法，开平方，用法类似java的bigint，实测速度比java的快很多
基于牛顿迭代法的高精度快速开方算法
01-13
基于牛顿迭代法的高精度快速开方算法 用于DSP
高精度计算器v1.3
02-04
自己编写了一个大数运算程序，建立了一个大数数据类型，可以类似于c++ int 一样定义数据，并封装了四则运算、三角函数，二进制转换，指数和对数函数，开平方等运算，要建立自己的大数运算程序，只要把此类的头文件...
C++高精度开平方
Rubik_xie
10-13 1471
#include <iostream> #include <vector> using namespace std; /* 主要思路：(x + 1)^2 = x^2 + 2x + 1 同样的的道理 (x + 10^i) = x^2 + 2*(10^i)*x + 10^(2i) 于是可以循环每次增加0.1，直到超界，确定第一个小数位 每次增加0.01，，确定第二个小数位 每次增加10^(-n)，确定第n位小数 */ /** * @brief 求一个数开方的正数部分
大数开根 高精度 平方根
code 4 fun
07-25 4269
手动开根号的基本方法： 1. 将被开方数从右向左每隔2位用撇号分开； 2. 从左边第一段求得算数平方根的第一位数字； 3. 从第一段减去这个第一位数字的平方，再把被开方数的第二段写下来，作为第一个余数； 4. 把所得的第一位数字乘以20，去除第一个余数，所得的商的整数部分作为试商（如果这个整数部分大于或等于10，就改用9左试商，如果第一个余数小于第一位数字乘以20的积，则得
N个数平方和的平方根--高精度算法
Hello.Aaric的博客
04-21 1874
N个数平方和的平方根，公式如下： 我们都知道，计算机浮点数的表示，越靠近0点，所表示的浮点数精度越高，如下图。 那么，如果按照上图的公式直接计算，所得的结果精度会丢失得非常严重。 算法设计 为了避免丢失精度，我们就有了设计算法的核心思想：在计算平方和时，将每个加数，都转换为0到1之间的小数。 在计算出所有元素的平方和之后，再乘以放大倍数，这样就可以减少计算过程中的精度损失。用下图所示的公式表示。 图中A即为放大倍数。那么我们如何获取放大倍数A呢？ 方法一： 在开始计算之前，先遍历
高精度算法
KING_阿飞的博客
10-26 4408
高精度 1.什么是高精度 高精度算法，属于处理大数字的数学计算方法。在一般的科学计算中，会经常算到小数点后几百位或者更多，当然也可能是几千亿几百亿的大数字。一般这类数字我们统称为高精度数，高精度算法是用计算机对于超大数据的一种模拟加，减，乘，除，乘方，阶乘，开方等运算。对于非常庞大的数字无法在计算机中正常存储，于是，我们可以将这个数字拆开，拆成一位一位的，或者是几位几位的存储到一个数组中， 用一个...
求平方根，要求精度到小数点后10位
01-13 3451
  这是一个算法题，之所以单独整理下，是因为这个算法题让我对算法有了灵感。仿佛打开了一扇门。 计算机语言转换   根据题目，我们可以将题目转换成计算机语言如下：求一个数的平方根，这个平方根k的取值范围在0~n之间，同时小数点后保持10位的精度我们最后的精度为0.0000000001，那么k必须同时满足k *k <=n,（k+0.0000000001） *（k+0.0000000001）> n。 解题思路   根据上面的条件，我们首先会发现k的取值在0~n之间，0 ~n之间的数是从小到排列的，我们
基于SSM+JSP的企业人事管理信息系统毕业设计(源码+录像+说明).rar
最新发布
05-09
基于SSM+JSP的企业人事管理信息系统毕业设计(源码+录像+说明).rar 【项目技术】 开发语言：Java 框架：ssm+jsp 架构：B/S 数据库：mysql 【演示视频-编号：420】 https://pan.quark.cn/s/b3a97032fae7 【实现功能】 实现了员工基础数据的管理，考勤管理,福利管理,薪资管理,奖惩管理,考核管理,培训管理,招聘管理,公告管理,基础数据管理等功能。
c++ 高精度开根号
10-07
高精度开根号是一个复杂的计算过程，需要使用特定的算法来实现。下面是一个常见的高精度开根号的算法，供你参考： 1. 首先，将待开根号的数转化为高精度数表示。可以使用字符串或数组来存储每一位的数字。 2. 定义...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值