Exponentiation（求高精度幂）

Exponentiation

Time Limit: 500MS		Memory Limit: 10000K
Total Submissions: 175340		Accepted: 42341

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

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

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    */

{

...

}

Source

East Central North America 1988

大意：

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

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

Input

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

Output

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

解题思路：

（1）pow精度不够

函数原型：double pow( double x, double y );

头文件：math.h/cmath(C++中)

功能：计算x的y次方

返回值：x不能为负数且y为小数，或者x为0且y小于等于0，返回幂指数的结果。

#include<math.h>  
#include<stdio.h>  
int main()  
{  
  double x=2.0,y=3.0;  
  printf("%lf raised to %lf is %lf
",x,y,pow(x,y));  
  return 0;  
}  

（2）模拟乘法运算过程

　　必须自己模拟乘法运算过程，进行高精度的运算。

　　题目把输入的数限制在了6位，即只有5位数字，方便了我们解题。

　　我们将输入数字，以字符串形式读入，找到小数所在的位数，计算出结果应包含的小数的位数，比如说第一个算式“95.123 12”的小数的位数应该有3*12位。

　　解题的关键在于进行数据的处理，即模拟整数乘法，使用倒序数组，为什么使用倒序数组呢？我们模拟一下竖式乘法过程，例如：123*123：

　　1  2  3

　x         3

——————

　　3  6  9

先用个位乘被乘数；

　　1  2  3

　x     2

——————

　　2  4  6

　 +    3  6   9

——————

　　2  7  12  9

在用十位乘被乘数，并相加。

对大于10的进行进位：2  7  12  9 ==》 2  8  2  9

　　1  2  3

　x  1

——————

　　1  2  3

　+     2  8  2  9

————————

　　1  4  11 2  9

在用百位乘被乘数，并相加。

对大于10的进行进位：1  4  11 2  9 ==》 1  5  1  2  9

　　从上面的乘法竖式中，我们是向前进位，由于我们不知道最后得到的数据的位数，所以采用倒序存储，向后进位；从0位开始乘，结果也从0位开始存，非常方便。这样得出的结果也是倒序的。

　　为了计算方便，我们不把数字多余的0去掉，而是在最后判断小数点的位置，然后输出该输出的数位。

　　每次乘法，都是用题目给的r乘上你上一次得出的结果，如果是第一次计算，那么就是r，计算的结果直接加到一个初始化为0的250大小的数组里面，注意是加。乘法的过程很容易模拟出来，就是让乘数让乘数第一位把你的结果的所有位乘一遍，然后再让第二位乘，注意加进数组时，有一个偏移量，乘法竖式都是这么写的，大家体会下。

　　开一个250的数组m存储结果，并且开一个250的数组jieguo存储中间结果，并且需要一个长度为6的int型数组存储输入的String类型的数据r。

　　输出结果时要小心，因为数组中存储的数位是倒序的，且没有小数点，需要计算从两边向中间的小数点方向第一个不为0数的位置。

#include<iostream>
#include<cstring>
#include<string>
#define MAX 250
using namespace std;
int main()
{
    string r;//底数
    int n,dian;
    short Chengshu[6];
    short m[MAX],jieguo[MAX];
    while(cin>>r>>n)
    {
        for(int i=0;i<=MAX;i++) {m[i]=jieguo[i]=0;}//初始化
        for(int j=0;j<6;j++) {Chengshu[j]=0;}
        dian = 0;//小数点位置
        size_t pos = r.find(".");
        if(pos != string::npos) dian = (5-pos)*n;
        for(int i=5,j=0;i>=0;i--)
        {//注意此处进行倒序存储
            if(r[i] != '.') {
                    Chengshu[j] = m[j] = jieguo[j] =  r[i]-'0';
                    //此处要给m[]赋值，当n=1时直接输出
                    j++;
            }
        }
        while(n>=2)//当乘幂大于等于2的时候,等于1可直接处理0输出
        {
            for(int i=0;i<MAX;++i) m[i]=0;
            for(int i=0;i<5;i++)
            {//chengshu[i]
                for(int j=0;j<MAX;j++)
                {
                    if(Chengshu[i]==0) break;
                    else{
                        m[i+j] += Chengshu[i]*jieguo[j];
                        //对>9 的进行处理
                        for(int t=i+j;m[t]>9;++t)//处理进位
                        {
                             m[t+1]+=m[t]/10;
                             m[t]=m[t]%10;
                        }
                    }
                }
            }
            //更新被乘数
            for(int k=0;k<MAX;k++)
            {
                 jieguo[k] = m[k];
            }
            n--;
        }
        int first = -1;
        for(int i=MAX-1;i>=dian;i--)
        {//从右向左查找第一个不为0的位
            if(m[i]>0)
            {
                first = i;break;
            }
        }
        int last = dian;
        for(int j=0;j<dian;j++)
        {//从左向右查找小数点后第一个不为0的位
            if(m[j]>0) {
                last = j;break;
            }
        }

        if(first != -1)//整数位不全为0
        {
            for(int k=first;k>=dian;k--)
                cout<<m[k];
        }

        if(last != dian)//有小数位
        {
            cout<<".";
            for(int k=dian-1;k>=last;k--)
                cout<<m[k];
        }
        cout<<endl;
    }
    return 0;
}

java中有一个类 ：java.math.BigDecimal

import java.io.*;
import java.util.*;
import java.math.BigDecimal;

public class Main
{
    public static void main(String args[])throws Exception
    {
        Scanner cin=new Scanner(System.in);
        while(cin.hasNext())
        {
            BigDecimal r=cin.nextBigDecimal();
            int n=cin.nextInt();
            r=r.pow(n).stripTrailingZeros();//去掉小数点后面的零
            String m_string=r.toPlainString();//不带指数段的字符串表示形式
            if(m_string.charAt(0)=='0')
            m_string=m_string.substring(1);
            System.out.println(m_string);
        }
    }
}