[POJ 1001] Exponentiation C++解题报告 JAVA解题报告

Exponentiation

Time Limit: 500MS		Memory Limit: 10000K
Total Submissions: 126980		Accepted: 30980

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 Rⁿ 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

Sample Output

548815620517731830194541.899025343415715973535967221869852721

.00000005148554641076956121994511276767154838481760200726351203835429763013462401

43992025569.928573701266488041146654993318703707511666295476720493953024

29448126.764121021618164430206909037173276672

90429072743629540498.107596019456651774561044010001

1.126825030131969720661201

Hint

If you don't know how to determine wheather encounted the end of input:
s is a string and n is an integer

C++

while(cin>>s>>n)

{

...

}

c

while(scanf("%s%d",s,&n)==2) //to  see if the scanf read in as many items as you want

/*while(scanf(%s%d",s,&n)!=EOF) //this also work    */

{

...

}

翻译：

求高精度幂

Time Limit: 500MS		Memory Limit: 10000K
Total Submissions: 126980		Accepted: 30980

Description

对数值很大、精度很高的数进行高精度计算是一类十分常见的问题。比如，对国债进行计算就是属于这类问题。

现在要你解决的问题是：对一个实数R( 0.0 < R < 99.999 )，要求写程序精确计算 R 的 n 次方(Rⁿ)，其中n 是整数并且 0 < n <= 25。

Input

T输入包括多组 R 和 n。 R 的值占第 1 到第 6 列，n 的值占第 8 和第 9 列。

Output

对于每组输入，要求输出一行，该行包含精确的 R 的 n 次方。输出需要去掉前导的 0 后不要的 0 。如果输出是整数，不要输出小数点。

解决思路

这是一道高精度的题，主要是处理前导0和末尾0的时候有点麻烦。例如100.00可能会处理成1。

源码

C++解题

   /*

   poj 1001

   version:1.0

   author:Knight

   Email:S.Knight.Work@gmail.com

   */

 #include<cstdio>

 #include<cstring>

 #include<cstdlib>

 #include<memory.h>

 using namespace std;

 char Result[];//存R^N的结果

 //大实数的乘法,乘数为FirMultiplier和SecMultiplier，结果存在Result中

 void HigRealMul(char* FirMultiplier, char* SecMultiplier, char* Result);

 //剔除实数尾部的无效0或小数点

 void CutInsignificantTail(char* StrR);

 //计算小数点在实数中的位数

 int CountPointIndex(char* StrR);

 //删除实数中的小数点,PointIndex为小数点在实数中从右向左数的第几位

 void DeletePoint(char* StrR, int PointIndex);

 int main(void)

 {

     char StrR[];//R对应的字符串

     int N;

     int i;

     int PointIndex = ;//记录小数点在实数中从右向左数的第几位，如1.26在第3位，4在第0位

     while(scanf("%s%d", StrR, &N) != EOF)

     {

         memset(Result, , );

         CutInsignificantTail(StrR);

         PointIndex = CountPointIndex(StrR);

         DeletePoint(StrR, PointIndex);

         strcpy(Result, StrR);

         for (i=; i<=N; i++)

         {

             HigRealMul(Result, StrR, Result);

         }

         int Len = strlen(Result);

         if (Len -(PointIndex - ) * N < )

         {

             printf(".");

             for (i = Len - (PointIndex - ) * N; i<; i++)

             {

                 printf("");

             }

         }

         for (i=; i<Len; i++)

         {

             //输出小数点

             if (i == Len -(PointIndex - ) * N)

             {

                 printf(".");

             }

             printf("%c", Result[i]);

         }

         printf("\n");

         //printf("%s\n", Result);

         //printf("%d\n", PointIndex);

     }

     return ;

 }

 //大实数的乘法,乘数为FirMultiplier和SecMultiplier，结果存在Result中

 void HigRealMul(char* FirMultiplier, char* SecMultiplier, char* Result)

 {

     char TmpResult[];

     int i,j;

     int k = -;//控制TmpResult[]下标

     int FirLen = strlen(FirMultiplier);

     int SecLen = strlen(SecMultiplier);

     memset(TmpResult, '', );

 //模拟乘法运算

     for (i=SecLen-; i>=; i--)

     {

         k++;

         int FirMul;

         int SecMul = SecMultiplier[i] - '';

         int Carry;//进位

         for (j=FirLen-; j>=; j--)

         {

             FirMul = FirMultiplier[j] - '';

             TmpResult[k + FirLen -  - j] +=   FirMul * SecMul % ;

             Carry = FirMul * SecMul /  + (TmpResult[k + FirLen -  - j] - '') / ;

             TmpResult[k + FirLen -  - j] = (TmpResult[k + FirLen -  - j] - '') %  + '';

             TmpResult[k + FirLen - j] += Carry;

         }

     }

 //防止某一位的值超过9

     for (k=; k<; k++)

     {

         TmpResult[k + ] += (TmpResult[k] - '') / ;

         TmpResult[k] = (TmpResult[k] - '') %  + '';

     }

 //将设置字符串结束符

     for (k=; k>=; k--)

     {

         if ('' != TmpResult[k - ])

         {

             TmpResult[k] = '\0';

             break;

         }

     }

 //将临时存储的答案TmpResult倒转变成我们熟悉的方式，存到Result中

     for (i=strlen(TmpResult)-,j=; i>=; i--,j++)

     {

         Result[j] = TmpResult[i];

     }

     Result[j] = '\0';

 }

 //剔除实数尾部的无效0或小数点

 void CutInsignificantTail(char* StrR)

 {

     int i;

     int PointIndex = CountPointIndex(StrR);

     int Len = strlen(StrR);

     if ( == PointIndex)

     {

         if ('.' == StrR[Len - ])

         {

             StrR[Len - ] = '\0';

         }

         return;

     }

     for (i=Len-; i>Len--PointIndex; i--)

     {

         if ('' == StrR[i] || '.' == StrR[i])

         {

             StrR[i] = '\0';

         }

         else

         {

             return ;

         }

     }

 }

 //计算小数点在实数中的位数

 int CountPointIndex(char* StrR)

 {

     int i;

     int Index = ;

     for (i = strlen(StrR); i>=; i--)

     {

         if ('.' == StrR[i])

         {

             break;

         }

         else

         {

             Index++;

         }

     }

     if (- == i)

     {

         Index = ;

     }

     return Index;

 }

 //删除实数中的小数点

 void DeletePoint(char* StrR, int PointIndex)

 {

     int i;

     int Len = strlen(StrR);

     for (i=strlen(StrR)-PointIndex; i<Len; i++)

     {

         StrR[i] = StrR[i+];

     }

 }

JAVA解题：

 import java.io.*;

 import java.util.*;

 import java.math.*;

 public class Main1001 {

     /**

      * @param args

      */

     public static void main(String[] args) {

         Scanner cinScanner = new Scanner(System.in);

         while (cinScanner.hasNextBigDecimal()) {

             BigDecimal r = cinScanner.nextBigDecimal();

             int n = cinScanner.nextInt();

             BigDecimal answerBigDecimal = r.pow(n);

             /*

              * stripTrailingZero();去除小数后边的0，例如16.000000使用这个方法后，就变成了16

              */

             answerBigDecimal = answerBigDecimal.stripTrailingZeros();

             /*

              * toPlainString();不使用科学计数法输出

              */

             String answerString = answerBigDecimal.toPlainString();

             if (answerString.startsWith("0.")) {

                 answerString = answerString.substring(1);

             }

             System.out.println(answerString);

         }

     }

 }

秒客网

[POJ 1001] Exponentiation C++解题报告 JAVA解题报告

解决思路

源码

相关文章