【学校OJ】 二分答案+高精度 高精度开平方

最新推荐文章于 2020-11-21 20:56:26 发布
最新推荐文章于 2020-11-21 20:56:26 发布
阅读量834 收藏
点赞数 2
分类专栏： -->分治做得像枚举<-- -->想想也是 UGLY<-- 文章标签： 分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C20190101ZJX/article/details/53812910
版权

题目描述

输入

一个整数 N。 

输出

N 的平方根下取整。 

样例输入

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

123456789012345678901234567890

样例输出

351364182882014

提示

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

    诈尸啦！诈尸啦！诈尸啦！重要的事情说三遍！

    我看到这题目描述也是醉了……这语言描述过于简单了吧……心中自是呕吐着……

    一看这规模，拿起重载运算符开始写了……泪奔中——这道题思路很好想，高精度二分答案，最低0，最高N，平一下方，尝试是否有可能，然后减少区间，It's so easy好吧，还是要乖乖的写会儿+ - * / ^ > <等一系列猥琐的运算符……重载运算符三天后，我终于写完了代码！用‘|’表示开根，真佩服我自己！

    凝结着吐出的鲜血的代码新鲜出炉：

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
struct Big
{
	int A[5005];
	int len;
	int f;
	Big()
	{
		memset(A,0,sizeof(A));
		len=1;
		f=0;
	}
	void print()
	{
		if(f)
			printf("-");
		for(int i=len;i>=1;i--)
			printf("%d",A[i]);
	}
	void read()
	{
		char _s[5005];
		scanf("%s",_s);
		len=strlen(_s);
		int k=0;
		if(_s[0]=='-')
		{
			f=1;
			len--;
			k++;
		}
		for(int i=1+k;i<=len+k;i++)
			A[i-k]=_s[len-i+2*k]-'0';
		while(!A[len]&&len>1)
			len--;
		if(len==1&&!A[1])
			f=0;
	}
	bool operator >(Big c)const
	{
		if(len>c.len)
			return 1;
		if(len<c.len)
			return 0;
		for(int i=len;i>=1;i--)
		{
			if(A[i]>c.A[i])
				return 1;
			if(A[i]<c.A[i])
				return 0;
		}
		return 0;
	}
	bool operator <(Big c)const
	{
		if(len<c.len)
			return 1;
		if(len>c.len)
			return 0;
		for(int i=len;i>=1;i--)
		{
			if(A[i]<c.A[i])
				return 1;
			if(A[i]>c.A[i])
				return 0;
		}
		return 0;
	}
	bool operator >=(Big c)const{Big a;memcpy(a.A,A,sizeof(A));a.len=len;a.f=f;return !(a<c);}
	bool operator <=(Big c)const{Big a;memcpy(a.A,A,sizeof(A));a.len=len;a.f=f;return !(a>c);}
	bool operator ==(Big c)const{Big a;memcpy(a.A,A,sizeof(A));a.len=len;a.f=f;return !(a>c)&&!(a<c);}
	bool operator !=(Big c)const{Big a;memcpy(a.A,A,sizeof(A));a.len=len;a.f=f;return !(a==c);}
	Big operator +(Big c)
	{
		Big g;
		Big a;memcpy(a.A,A,sizeof(A));a.len=len;a.f=f;
		g.len=max(len,c.len)+1;
		if(f==c.f)
			g.f=f;
		else
			if(f==1)
			{
				g=a;
				g.f=0;
				g=c-g;
				return g;
			}
			else
			{
				g=c;
				g.f=0;
				g=a-g;
				return g;
			}
		for(int i=1;i<=g.len;i++)
		{
			g.A[i]+=A[i]+c.A[i];
			g.A[i+1]+=g.A[i]/10;
			g.A[i]%=10;
		}
		if(!g.A[g.len])
			g.len--;
			
		if(g.len==1&&!g.A[1])
			g.f=0;
		return g;
	}
	Big operator -(Big c)
	{
		Big g;
		Big a;memcpy(a.A,A,sizeof(A));a.len=len;a.f=f;
		if(f==c.f)
			g.f=f;
		else
			if(f==1)
			{
				g=c;
				g.f=1;
				g=g+a;
				return g;
			}
			else
			{
				g=c;
				g.f=0;
				g=a+g;
				return g;
			}
		if(a>=c)
		{
			g.len=len;
			for(int i=1;i<=len;i++)
			{
				g.A[i]+=A[i]-c.A[i];
				if(g.A[i]<0)
				{
					g.A[i]+=10;
					g.A[i+1]--;
				}
			}
			for(int i=len;i>=2;i--)
			{
				if(g.A[i])
					break;
				g.len--;
			}
		}
		else
		{
			g.len=c.len;
			for(int i=1;i<=c.len;i++)
			{
				g.A[i]+=c.A[i]-A[i];
				if(g.A[i]<0)
				{
					g.A[i]+=10;
					g.A[i+1]--;
				}
			}
			for(int i=len;i>=2;i--)
			{
				if(g.A[i])
					break;
				g.len--;
			}
			g.f=!g.f;
		}
		return g;
	}
	Big operator *(Big c)const
	{
		Big g;
		if((len==1&&!A[len])||(c.len==1&&!c.A[c.len]))
			return g;
		if(f!=c.f)
			g.f=1;
		for(int i=1;i<=len;i++)
		{
			for(int j=1;j<=c.len;j++)
			{
				g.A[i+j-1]+=A[i]*c.A[j];
				if(g.A[i+j-1]>=10)
				{
					g.A[i+j]+=g.A[i+j-1]/10;
					g.A[i+j-1]%=10;
				}
			}
		}
		g.len=len+c.len;
		if(!g.A[len+c.len])
			g.len--;
		return g;
	}
	Big operator /(Big c)const
	{
		Big a;memcpy(a.A,c.A,sizeof(c.A));a.len=c.len;
		Big ten;ten.len=2;ten.A[2]=1;
		Big one;one.A[1]=1;
		Big zero;
		if(c.len==1&&c.A[1]==0)
			return zero;
		Big g;
		for(int i=len;i>=1;i--)
		{
			zero=zero*ten;
			zero.A[1]=A[i];
			while(zero>=a)
			{
				zero=zero-a;
				Big t=ten^(i-1);
				g=g+t;
			}
		}
		Big O;
		if(g.len==1&&!g.A[1])
			return O;
		g.f=f==c.f?0:1;
		return g;
	}
	Big operator %(Big c)const
	{
		Big a;memcpy(a.A,c.A,sizeof(c.A));a.len=c.len;a.f=f;
		Big ten;ten.len=2;ten.A[2]=1;
		Big one;one.A[1]=1;
		Big zero;
		if(c.len==1&&c.A[1]==0)
			return zero;
		for(int i=len;i>=1;i--)
		{
			zero=zero*ten;
			zero.A[1]=A[i];
			while(zero>=a)
				zero=zero-a;
		}
		return zero;
	}
	Big operator ^(int k)const
	{
		Big op;
		Big a;memcpy(a.A,A,sizeof(A));a.len=len;a.f=f;
		op.A[1]=1;
		if(k==0)
			return op;
		Big pi=(a^(k/2));
		op=pi*pi;
		if(k%2)
			op=op*a;
		return op;
	}
	Big operator |(int k) const
	{
		Big a;memcpy(a.A,A,sizeof(A));a.len=len;
		Big two;two.A[1]=2;
		Big one;one.A[1]=1;
		Big l;
		Big r=a;
		Big m;
		for(;l<r;)
		{
			m=(l+r+one)/two;
			if((m^k)>a)
				r=m-one;
			else
				l=m;
		}
		return l;
	}
}num,num2;
int main()
{
	num.read();
	num2=num|2;
	num2.print();
}

    有没有被惊艳到？我就是喜欢写高精度！加减乘除方根一定要考虑负数，能写高精弄高精就不写高精弄低精（不然怎么会用了三天），自信满满地提交上去——TLE，好吧我知错了QAQ，看来不要想太多啊……除法就除以一个2写成高精度当然耗时啊……算了，写简单点吧……顺便压个位（超时肯定有位数的缘故——1000位不超才怪嘞）。int压4位——超时，int压5位——溢出，long long压5位——超时……历经无数次尝试，我盖起了一座鲜红的大楼……╮(╯▽╰)╭，最后，终于long long压8位过了！ 

#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<ctime>
using namespace std;
struct Big
{
	long long A[5005];
	int len;
	int f;
	Big()
	{
		memset(A,0,sizeof(A));
		len=1;
		f=0;
	}
	void print()//
	{
		printf("%lld",A[len]);
		for(int i=len-1;i>=1;i--)
			printf("%08lld",A[i]);
	}
	void read()//
	{
		char _s[5005];
		scanf("%s",_s);
		len=(strlen(_s)+7)/8;
		int slen=strlen(_s);
		for(int i=1;i<=slen;i++)
		{
			int o=slen-i,p=(i+7)/8;
			A[p]+=(_s[o]-'0')*pow(10,(i-1)%8);
		}
	}
	bool operator <(Big c)const
	{
		if(len<c.len)
			return 1;
		if(len>c.len)
			return 0;
		for(int i=len;i>=1;i--)
		{
			if(A[i]<c.A[i])
				return 1;
			if(A[i]>c.A[i])
				return 0;
		}
		return 0;
	}
	Big operator +(Big c)const//
	{
		Big g;
		g.len=max(len,c.len)+1;
		for(int i=1;i<=g.len;i++)
		{
			g.A[i]+=A[i]+c.A[i];
			g.A[i+1]+=g.A[i]/100000000;
			g.A[i]%=100000000;
		}
		if(!g.A[g.len])
			g.len--;
		return g;
	}
	Big operator -(Big c)const//
	{
		Big g;
		Big a;memcpy(a.A,A,sizeof(A));a.len=len;a.f=f;
		g.len=len;
		for(int i=1;i<=len;i++)
		{
			g.A[i]+=A[i]-c.A[i];
			if(g.A[i]<0)
			{
				g.A[i]+=100000000;
				g.A[i+1]-=1;
			}
		}
		for(int i=len;i>=2;i--)
		{
			if(g.A[i])
				break;
			g.len--;
		}
		return g;
	}
	Big operator *(Big c)const//
	{
		Big g;
		if((len==1&&!A[len])||(c.len==1&&!c.A[c.len]))
			return g;
		for(int i=1;i<=len;i++)
		{
			for(int j=1;j<=c.len;j++)
			{
				g.A[i+j-1]+=A[i]*c.A[j];
				if(g.A[i+j-1]>=100000000)
				{
					g.A[i+j]+=g.A[i+j-1]/100000000;
					g.A[i+j-1]%=100000000;
				}
			}
		}
		g.len=len+c.len;
		if(!g.A[len+c.len])
			g.len--;
		return g;
	}
	Big operator /(int k)const//
	{
		Big g;
		int sum=0;
		for(int i=len;i>=1;i--)
		{
			sum*=100000000;
			sum+=A[i];
			int o=sum/k;
			if(o)
				g.len=max(i,g.len);
			g.A[i]=o;
			sum%=k;
		}
		return g;
	}
	Big operator ^(int k)const
	{
		Big op;
		Big a;memcpy(a.A,A,sizeof(A));a.len=len;a.f=f;
		op.A[1]=1;
		if(k==0)
			return op;
		Big pi=(a^(k/2));
		op=pi*pi;
		if(k%2)
			op=op*a;
		return op;
	}
	Big operator |(int k)const
	{
		Big a;memcpy(a.A,A,sizeof(A));a.len=len;
		Big one;one.A[1]=1;
		Big l;
		Big r=a;
		Big m;
		for(;l<r;)
		{
			m=(l+r+one)/2;
			if(a<(m^k))
				r=m-one;
			else
				l=m;
		}
		return l;
	}
}num,num2,num3;
int p;
int main()
{
	num.read();
	(num|2).print();
}
    鲜血的教训啊~~~

Starlight_Glimmer
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
求一个数的平方根（向下取整）
apple_59012575的博客
09-19 720
#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 <
pythonsqrt取整函数_Python math.isqrt() 方法
weixin_39656686的博客
11-30 3089
Python math.isqrt() 方法例如：将平方根向下取整至最接近的整数：# Import math Libraryimport math# 打印出不同数字的平方根print (math.sqrt(10))print (math.sqrt(12))print (math.sqrt(68))print (math.sqrt(100))# 将平方根向下取为最接近的整数print (math.i...
平方根
wew_king的博客
05-17 1961
#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",&
二分练习--oj2781
Gverzh的博客
11-21 166
二分练习 原题链接 Description 给你一个序列，然后给你m个元素，让你从序列中找出与每个元素最接近的数字输出来，如果有两个就输出两个。 Input 多组输入，第一行给你两个数n（0 < n < 10000000）,m(0 < m < n),接下来是数列的n个数，然后再输入m个元素，让你找出最接近每个元素的值。如果有两个，按从小到大输出。 Output 这m个数分别输出最接近每个元素的值，组与组之间输出一个空行。 Sample Input 8 4 1 2 3 4 5 6 8
高精度开方
weixin_30737433的博客
10-17 238
　　X的二分之一次方怎么求？二分！ 　　首先求整数部分，从1到X二分答案，选择最接近的那个 　　然后是求第一位小数部分，用高精度乘法模拟平方，看看得出的数是否比X大，或者比X小，从0到9不断二分即可 　　然后是第二位小数...... 　 View Code 1 #include<iostream> 2 #include<string> ...
java课程作业+北邮+OJ+已通过+黑杰克
06-02
【标题】"java课程作业+北邮+OJ+已通过+黑杰克"揭示了这是一个关于Java编程的课程作业，它与北京邮电大学（北邮）的在线编程平台（Online Judge，简称OJ）相关，并且这个作业是关于“黑杰克”游戏的实现。...
hustoj A+B问题16种语言及答案
11-08
hustoj A+B问题16种语言及答案
大数高精度运算库
10-20
标题中的“大数高精度运算库”指的是在计算过程中处理非常大的整数或者浮点数时，需要使用的一种特殊库。这些库能够提供超过标准数据类型（如int、float）所能表示的数值范围，保证计算的精确性。在数学、科学计算、...
poj1001高精度乘法
10-19
Problems involving the computation of exact values of very large magnitude and precision are common. For example, the computation of the national debt is a taxing experience for many ...北大OJ平台（代理
练习题（含答案）_c++oj答案_c++类oj习题_
09-29
这个压缩包文件"练习题（含答案）_c++oj答案_c++类oj习题_"似乎包含了一系列关于C++类与对象的在线判断题（Online Judge, OJ）解答，这对于学习者来说是一个宝贵的资源，可以帮助他们检验和提升在类和对象方面的理解...
浅谈二分答案
asddsa2010的博客
09-11 426
二分答案，就是二分枚举答案，由于进行二分，所以复杂度log(n)，比直接 for的时间更短。 【问题描述】 记得上学那会， Fbs同学经常会欺负萝卜同学。有一次，他出了这么一道题目，想为难一下萝卜同学。题目是这样的： 有N个整数X_i， X_i值的范围从0到1000000000。要从中选出C个数（ 2<=C<=N），使得任意两个数差...
历届试题 矩阵翻硬币 蓝桥杯 大数开方 大数相乘
colorfulshark
02-12 6393
历届试题 矩阵翻硬币   时间限制：1.0s   内存限制：256.0MB 锦囊1 锦囊2 锦囊3 问题描述 　　小明先把硬币摆成了一个 n 行 m 列的矩阵。 　　随后，小明对每一个硬币分别进行一次 Q 操作。 　　对第x行第y列的硬币进行 Q 操作的定义：将所有第 i*x 行，第 j*y 列的硬币进行翻转。
大数开平方
AcmHonor的专栏
02-11 1027
手动开根号
面试题85：按指定精度打印开方后的结果
tianya_team
04-14 725
题目： 如何求根号2的值，并且按照我的需要列出指定小数位。 思路： 牛顿迭代法求根号，setprecision 函数控制输出精度。 #include #include #include #include #include #include #include #include using namespace std; double my_sqrt(double
求一个数的平方根，给定它的精度
zhaohoutao的博客
07-14 1253
double my_sq(double num, double detal) { double low = 0; double high = num; double mid = (low + high) / 2; while (fabs(mid*mid - num) > detal) { if (mid*mid > num) high = mid; else i...
luogu1480高精度除以高精度
liusu201601的博客
03-18 684
题目传送门1 目前只有60分，下次差错更新#include&lt;cstdio&gt; #include&lt;cstring&gt; //高精度a除以高精度 b //预处理b的1-10倍 // 取lb 的长度 la //比较 大小 //减法 char s[5100],l; struct nod{int l,f,a[5100];nod(){l=1;memset(a,0,...
高精度整数开根号算法
Arnold_wang
02-14 4165
//高精度整数开根号算法 //假设被开方数为y(16位)，而开方结果为x(8位),并且表示为一下格式:(32位开方类似) //y = a15*2^15 + a14*2^14 +...+ a1*2^1 + a0*2^0; //x = b7*2^7 + b6*2^6 + ... + b1*2^1 + b0^0; unsigned int sqrt_int(unsigned int y) {
ACM-高精度模板(综合篇)
哇哈哈的专栏
02-01 9521
在这里，我们约定，能用int表示的数据视为单精度，否则为高精度。所有函数的设计均采用带返回值的形式。 本文包含 1.高精度加法 2.高精度减法 3.高精度乘法 1）高精度乘高精度的朴素算法 2）高精度乘高精度FFT优化算法 3）高精度乘单精度 4.高精度除法 1）高精度除高精度 2）高精度除单精度 5.高精度取模 1）高精度对高精度取模 2）高精度对单精度取模 6.高精
OJ------浮点数取整
nameix的博客
08-12 553
四舍五入取整 例如：5.5 输出：6 import java.util.*; public class Main{ public static void main(String[] args){ Scanner sc=new Scanner(System.in); while(sc.hasNext()){ float f=sc.nextFloat(); System.out.println(
OJ高精度加法c语言
最新发布
06-24
在计算机科学中，尤其是在线竞赛（OJ，Online Judge）中，处理高精度加法是一个常见的任务，因为通常涉及的大整数超出了标准数据类型（如int或long long）的范围。在C语言中，要实现高精度加法，一种常用的方法是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值