poj 1001

最新推荐文章于 2019-12-01 23:05:10 发布
原创 最新推荐文章于 2019-12-01 23:05:10 发布 · 492 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#poj #c++ #1001

懒了很久终于又来刷题，还从最简单的开始，暴露出不少问题。

本来是个最简单的问题，大数高精度计算，因为种种原因居然写了两个小时才AC。菜到家了难过

题目的描述：

Description

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 computer systems. 

This problem requires that you write a program to compute the exact value of Rn where R is a real number ( 0.0 < R < 99.999 ) and n is an integer such that 0 < n <= 25.

Input

The input will consist of a set of pairs of values for R and n. The R value will occupy columns 1 through 6, and the n value will be in columns 8 and 9.

Output

The output will consist of one line for each line of input giving the exact value of R^n. Leading zeros should be suppressed in the output. Insignificant trailing zeros must not be printed. Don't print the decimal point if the result is an integer.

Sample Input

95.123 12
0.4321 20
5.1234 15
6.7592  9
98.999 10
1.0100 12

Sample Output

548815620517731830194541.899025343415715973535967221869852721
.00000005148554641076956121994511276767154838481760200726351203835429763013462401
43992025569.928573701266488041146654993318703707511666295476720493953024
29448126.764121021618164430206909037173276672
90429072743629540498.107596019456651774561044010001
1.126825030131969720661201

第一眼看上去挺简单的，不就是用数组算嘛，连题都没看完，很快就写好代码了。读入一个float，一个int，算出float的小数位数，然后把float存入数组，计算结果，输出结果。提交，WA。

很不服气地拿sample一比较，发现5.1234 15居然错了。其实之前就意识到这个问题了，只是抱着侥幸心理忽略了：C++的浮点数不精确。5.1234被当成5.123999还是5.1234001来着，位数一大肯定错了。

改成string，因为不熟悉C++，又在strlen和string.length和string.length()之间折腾了一会儿，最后一个才是对的，strlen的参数必须是const char*。提交，依然WA。

仔细一对比，发现纯小数前面的0要省略。改过来，提交，WA。

再仔细一对比，发现小数最后的无意义的0要省略。改过来，提交，WA。

这次没有参照了。自己想想吧，试着输入整数，发现后面跟了小数点。改过来，我已经开始心虚了，提交，WA。

还是没有放弃，想了想还有什么特例。输入1.00，发现这个情况没处理，输出为1.00。改过来，提交，忐忑万分，果然没失望还是WA。

继续想想，试着输入0.000，发现这个情况没考虑，输出了0.000 。改过来，我简直不能相信过不了。最后依然是WA。

我已经被折磨得不行了，决定从网上找测试数据。

然后果然又发现两个问题，一个大问题是前后的省略0没处理好导致10.000 1这样的数据会被处理成1输出。一个小问题是 0 0这样的输入会输出成0 。

把这两个问题解决掉，才终于AC了。实在没想到简单的一道题能做成这样。代码看起来丑陋不堪，效率也非常低下，非常伤心，整理之后如下：

// Problems.cpp : 定义控制台应用程序的入口点。
//

#include <iostream>
#include <string>
#include <math.h>

using namespace std;
const int LENGTH = 600;

void calBigInt(int nums[LENGTH], int n){
	
	int tmp[LENGTH];
	int tmpResult[LENGTH];
	int tlength, length = 0;
	while(nums[length]>=0)length++; //length of nums
	memcpy(tmpResult,nums,sizeof(int) * LENGTH);
	for(int i = 0; i < n-1; i ++)
	{
		memset(tmp,-1,sizeof(int) * LENGTH);
		tlength = 0;
		while(tmpResult[tlength]>=0)tlength++; //length of tmpResult
		
		for(int j = 0; j < length; j++)//the jth number multiple with the tmp result
		{
			for(int k = 0; k < tlength; k++)
			{
				if(tmp[j+k] == -1)tmp[j+k] = 0;
				tmp[j+k] += nums[j] * tmpResult[k];
				if(tmp[j+k] >= 10)
				{
					if(tmp[j+k+1] == -1)tmp[j+k+1]=0;
					tmp[j+k+1] += tmp[j+k]/10;
					tmp[j+k] = tmp[j+k]%10;
				}
			}
		}
		tlength = 0;
		while(tmp[tlength]>=0)tmpResult[tlength] = tmp[tlength++];
	}
	memcpy(nums,tmpResult,sizeof(int) * LENGTH);
}

int main()
{
    string s;
	int n,t,length,start;
	int nums[LENGTH];
	while(cin >> s >> n)
    { 
		if(n == 0){
			cout<<1<<endl;continue;
		}
		
		///init of params
		memset(nums,-1,sizeof(int) * LENGTH);//init 
		t = 0;			//float count
		length = 0;		//be used as index
		
		int i = s.length() -1;
		while(i>=0)		  //transfer string to array
		{
			if(s[i]=='.'){// position of dot
				t = s.length() - 1 - i;
				i--;
				continue;
			}
			nums[length++] = s[i--] - '0';
		}

		t *= n;				//final float count
		calBigInt(nums,n);	//calculation

		///handle prefix 0 and suffix 0
		length = 0;
		while(nums[length]>=0)length++; 
		while(length >= 1 && nums[length-1]==0)length--;//length of effective number
		if(length == 0){
			cout << 0 << endl;continue;
		}
		start = 0;
		if(t > 0)//suffix 0
		{
			for(i = 0; i < t; i++)
			{
				if(nums[i]==0)continue;
				break;
			}
			start = i;
		}

		if(t >= length)//prefix 0 of pure decimal
		{
			cout<<".";
			for(i = 0; i < t-length; i++)
			{
				cout<<"0";
			}
		}
		
		for(i = length-1; i >= start; i --)
		{
			cout<<nums[i];
			if(i == t && t > start)cout<<".";
		}
		cout<<endl;
	}
	
    return 0;
}

但是我记得有一个更高效的计算幂的方法，矩阵幂运算。

比如要计算3^5 ，result = 1，先算tmp=3^(2^0)=3，5%2=1，所以result*=tmp=3, 然后3^(2^1) = 9, 5>>1=2%2=0, 什么也不干；然后3^(2^2)=81, 2>>1=1%2=1, 所以result*=tmp=243。这个方法可以极大地提高效率。试一试，把算法换成：

/**
 * Calculate the two numbers and save result to the first
 */
void CalTwoBigInt(int number1[LENGTH], int number2[LENGTH]){
	int length1 = 0, length2 = 0, length = 0;
	int result[LENGTH];
	while(number1[length1]>=0)length1++; //length of num1
	while(number2[length2]>=0)length2++; //length of num2
	memset(result, -1, LENGTH * sizeof(int));
	for(int j = 0; j < length2; j++)     //every number of num2 multiple with number1
	{
		for(int i = 0; i < length1; i++)
		{
			if(result[i+j] == -1)result[i+j] = 0;
			result[i+j] += number1[i] * number2[j];
			if(result[i+j]>=10)
			{
				if(result[i+j+1] == -1) result[i+j+1] = 0;
				result[i+j+1] += result[i+j]/10;
				result[i+j] %= 10;
			}
		}
	}
	memcpy(number1,result,LENGTH * sizeof(int));
}

void QuickCalBigInt(int nums[LENGTH], int n){
//	if(n < 0) throw exception("n must be a positive number.");
	if(n <= 0){
		memset(nums,0,LENGTH * sizeof(int));return;
	}
	if(n == 1)return;

	int num2[LENGTH], result[LENGTH];
	memset(result, -1, LENGTH * sizeof(int));
	memcpy(num2,nums,LENGTH * sizeof(int));
	result[0] = 1;
	while(true)
	{
		if(n%2 == 1)
		{
			CalTwoBigInt(result,num2);
		}
		n >>= 1;
		if(n == 0)break;
		CalTwoBigInt(num2, num2);
	}
	memcpy(nums,result,LENGTH * sizeof(int));
}

结果反而慢了。这个结果不能接受。自己测了几遍，发现只有当数据比较大的时候，后者才有略微的优势，大概也就提高了一倍的效率。

真是备受打击。


附：测试数据

输入：

99.001  3
99.010  1
99.010  3
99.100  1
99.100  3
95.123 12
0.4321 20
5.1234 15
6.7592  9
98.999 10
1.0100 12
.00001  1
.12345  1
0001.1  1
1.1000  1
10.000  1
000.10  1
000000  1
000.00  1
.00000  0
000010  1
000.10  1
0000.1  1
00.111  1
0.0001  1
0.0001  3
0.0010  1
0.0010  3
0.0100  1
0.0100  3
0.1000  1
0.1000  3
1.0000  1
1.0000  3
1.0001  1
1.0001  3
1.0010  1
1.0010  3
1.0100  1
1.0100  3
1.1000  1
1.1000  3
10.000  1
10.000  3
10.001  1
10.001  3
10.010  1
10.010  3
10.100  1
10.100  3
99.000  1
99.000  3
99.001  1
99.001  3
99.010  1
99.010  3
99.100  1
99.100  3
99.998  1
99.998  3
95.123 12
0.4321 20
5.1234 15
6.7592  9
98.999 10
1.0100 12
.00001  1
.12345  1
0001.1  1
1.1000  1
10.000  1
000.10  1
000010  1
000.10  1
0000.1  1
00.111  1
0.0001  1
0.0001  3
0.0010  1
0.0010  3
0.0100  1
0.0100  3
0.1000  1
0.1000  3
1.0000  1
1.0000  3
1.0001  1
1.0001  3
1.0010  1
1.0010  3
1.0100  1
1.0100  3
1.1000  1
1.1000  3
10.000  1
10.000  3
10.001  1
10.001  3
10.010  1
10.010  3
10.100  1
10.100  3
99.000  1
99.000  3
99.001  1
99.001  3
99.010  1
99.010  3
99.100  1
99.100  3
99.998  1
99.998  3
10.100  1
10.100  3
99.000  1
99.000  3
99.001  1
99.998  1

输出：

970328.403297001
99.01
970593.059701
99.1
973242.271
548815620517731830194541.899025343415715973535967221869852721
.00000005148554641076956121994511276767154838481760200726351203835429763013462401
43992025569.928573701266488041146654993318703707511666295476720493953024
29448126.764121021618164430206909037173276672
90429072743629540498.107596019456651774561044010001
1.126825030131969720661201
.00001
.12345
1.1
1.1
10
.1
0
0
1
10
.1
.1
.111
.0001
.000000000001
.001
.000000001
.01
.000001
.1
.001
1
1
1.0001
1.000300030001
1.001
1.003003001
1.01
1.030301
1.1
1.331
10
1000
10.001
1000.300030001
10.01
1003.003001
10.1
1030.301
99
970299
99.001
970328.403297001
99.01
970593.059701
99.1
973242.271
99.998
999940.001199992
548815620517731830194541.899025343415715973535967221869852721
.00000005148554641076956121994511276767154838481760200726351203835429763013462401
43992025569.928573701266488041146654993318703707511666295476720493953024
29448126.764121021618164430206909037173276672
90429072743629540498.107596019456651774561044010001
1.126825030131969720661201
.00001
.12345
1.1
1.1
10
.1
10
.1
.1
.111
.0001
.000000000001
.001
.000000001
.01
.000001
.1
.001
1
1
1.0001
1.000300030001
1.001
1.003003001
1.01
1.030301
1.1
1.331
10
1000
10.001
1000.300030001
10.01
1003.003001
10.1
1030.301
99
970299
99.001
970328.403297001
99.01
970593.059701
99.1
973242.271
99.998
999940.001199992
10.1
1030.301
99
970299
99.001
99.998

POJ 1001——高精度快速幂
qq_43513855的博客
02-24 1171
POJ 1001——高精度快速幂 本题主要用到两个东西，一个是高精度，一个是快速幂。 虽然是浮点数的乘法，但是实际上可以转化为整数的乘法，然后再用高精度乘法，高精度算法本身不难，但是在没重载运算符的情况下使用数组还是挺麻烦的，不少地方的初始化都需要特别注意。 关于数组的初始化： 数组名在函数内部时，它的sizeof数组名获得的是数组本身的长度，而数组作为函数形参的时候，sizeof获得的是这个指针本身的长度，这一点特别坑，这会导致memset函数出现问题。 关于快速幂： 快速幂是一种快速求出数字的幂的方法，
POJ1001算法解析
geek_jerome的博客
08-08 510
POJ1001 求高精度幂 Time Limit: 500MS Memory Limit: 10000K Total Submissions: 170716 Accepted: 41349Description 对数值很大、精度很高的数进行高精度计算是一类十分常见的问题。比如，对国债进行计算就是属于这类问题。现在要你解决的问题是：对一个实数R( 0.0 < R < 9
POJ1001
wyj_2016的博客
03-17 464
C++源代码： // Exponentiation// 2017.03.13 by wyj (COPY)#include using namespace std;// 计算 多 乘以 一 的情况，例如，1234 * 4// many: 多位数// one: 单位数// offset: 乘10偏移// return: 返回计算结果char * MMO(char * many, char one,
POJ 1001
weixin_45672615的博客
12-01 235
定义 初始化 将去小数点的原始数组复制 对应位数相乘，然后累加，进位处理 //说明： 比如： 1 2 3 4 5 6 0 0 0 7 8 9 //相乘（假设789是底数） —————— 外循环对 7 8 9 从个位到百位遍历 内循环对 1 2 3 4 5 6 从个位到百位遍历 乘积固定到一个新数组（元素较多） 即 9*6，9*5，9*4，9*3，9*2...
poj1001
Mr Lin 的专栏
10-07 374
没事AA题 生活还不是美滋滋。很久没做ACM题目了，算不上老司机，纯粹打酱油。由于不喜欢写备注 发现很多题目自己曾经做过但再去看却没头绪，所以决定今后把解题报告写在博客上。养成写备注的好习惯 此题主要是细节处理需要注意。本人WA三次 第四次才AC 此题分为三个步骤 1.去小数点存储。 2.大数运算。 3.确定小数点位置,去前导0后导0。#include<iostream> #includ
Poj1001
山重水复疑无路,柳暗花明又一村
03-22 249
代码： #include &lt;iostream&gt; using namespace std; int main() { unsigned int n; while (cin&gt;&gt;n) { cout&lt;&lt;(n+1)*n/2&lt;&lt;endl&lt;&lt;endl; } ...
POJ 1001 题解
远见望远的博客
09-29 141
题意：求一个实数R的N次方 解法思路：快速幂适用于整数计算，因此排除裸快速幂。题目中描述的R是一个固定长度的字符串，因此可以将小数点提取出来转换成一个整数来计算，完成后再用小数长度来确定小数点。计算N次方的时候发现N较小，所以可以使用高精度乘法来解决这个问题。 #include<iostream> #include<string> using namespace std...
POJ 1001 Exponentiation
Medlen
11-18 380
Exponentiation Time Limit: 500MS Memory Limit: 10000K Total Submissions: 183326 Accepted: 44108 Description Problems involving the computation of exact values of very large magnitude and precision a...
poj1001源码
05-02
poj1001源码，c语言版，通过ac，包含注释，容易懂
POJ1001的一个解决方案
05-25
简单地poj1001代码，是典型的利用数组输出结果的方法，关键的是测试数据。
POJ1001 （求高精度幂，Exponentiation，C++）
qq_45246359的博客
06-20 691
北京大学程序在线评测系统 (“PekingUniversityOnlineJudge”) POJ1001 （求高精度幂，Exponentiation，C++） 题目的网址 题目大意是对一个实数R( 0.0 < R < 99.999 )，精确计算 R 的 n 次方，其中n 是整数并且 0 < n <= 25。 具体思路在代码中的注释中都有体现，不做过多解释。 话不多说，具体代...
[hiho]#1041 : 国庆出游 树的前序遍历校验
剑心琴魄
10-01 1993
说实话小hi和小ho这对基友也是真爱，秀得单身狗一愣一愣的。 描述 小Hi和小Ho准备国庆期间去A国旅游。A国的城际交通比较有特色：它共有n座城市(编号1-n)；城市之间恰好有n-1条公路相连，形成一个树形公路网。小Hi计划从A国首都(1号城市)出发，自驾遍历所有城市，并且经过每一条公路恰好两次——来回各一次——这样公路两旁的景色都不会错过。 令小Hi苦恼的是他的小伙伴小Ho希望能以某种特定
leetcode word ladder 2
剑心琴魄
07-29 773
做了三天。从一开始的只会用b
[hiho]#1067 : 最近公共祖先·二 离线算法
剑心琴魄
10-06 703
描述：（原题地址：http://hihocoder.com/problemset/problem/1067?sid=601284） 给定一颗树，给出树根，以及一些查询pair，要求输出每条查询pair的最近公共节点。 保证所有查询节点都在这棵树上。 输入：第一行一个整数N代表边数，之后N行每行两个节点分别是一对父子，其中第一对父子中的父节点是root。 之后是一个整数M代表查询数，之后M行
leetcode candy
剑心琴魄
07-24 678
我去又TLE，拿数据本地测才80ms，
leetcode sort list
剑心琴魄
07-19 666
链表排序。要求O(nlogn), 固定空间复杂度。 首先用
TopCoder ChessMetric
剑心琴魄
04-16 663
问题：假如在一个棋盘上，骑士每一步只能走离自己一格的地方（包括斜线），或者走L行（如马的走法）。 比如K可以走的地方如下，包括X和L： ....... ..L.L.. .LXXXL. ..XKX.. .LXXXL. ..L.L.. ....... 在一个size * size大的棋盘，求从start[2] 经过numMoves步走到 en
[hiho]#1069 : 最近公共祖先·三 线段树|树转数组
剑心琴魄
10-06 636
描述：（原题地址：http://hihocoder.com/problemset/problem/1069?sid=601396） 给定一颗树，给出树根，以及一些查询pair，要求输出每条查询pair的最近公共节点。 保证所有查询节点都在这棵树上。 输入：第一行一个整数N代表边数，之后N行每行两个节点分别是一对父子，其中第一对父子中的父节点是root。 之后是一个整数M代表查询数，之后M行
POJ1001-Precision power：AC代码及解题报告
【标题】: POJ1001-Precision power 【描述】: 本篇内容提供了对北京大学在线评测系统（POJ）中的题目POJ1001-Precision power的详细解题报告和通过该题目的AC代码（Accepted Code），供读者学习参考。 【标签】: ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值