【ACM】求高精度幂

题目来源：http://poj.org/problem?id=1001&lang=zh-CN

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　求高精度幂

Time Limit: 500MS		Memory Limit: 10000K
Total Submissions: 160807		Accepted: 39157

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
。如果输出是整数，不要输出小数点。

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

求解思路：
1、使用数组存储数据，保证数组的元素不大于9，不存储小数点，通过一个整型变量记录小数位的位数。用string接受输入流的数据，再转换成整型数组（不含“.”）,作为第一次乘法计算的一个因子，并生成一个整数作为另一个因子。
2、核心函数是 void multiplicationCompute(vector<int> &ivecA, unsigned int &pointPosA, const int &intR, const int &pointPosR)，计算数组存储的大整数与底数的乘积。
   为了方便计算，大整数存储在数组的高位— —低位。计算的时候，从数组低位— —高位开始遍历，每一位数组元素（非-1占位符）与底数相乘，并将结果依次存入数组。对于ivecA[index] 与底数的乘积，其个位存入index位，其更高位依次存入index--位。循环调用函数计算，其最终结果存储在ivecA中。
3、输出控制。整数不输出小数点；小数位后缀0不输出；纯小数不输出小数点前面的0；如果ivecA存储的实数位小于小数位，则需要在前面补0。

不过很惭愧的是下面的代码提交未能通过。在本机测试结果都正确，但是提交结果却是wrong answer，一时半会也没找到错误原因，待回头再来看吧。

 #include <iostream>
 #include <string>
 #include <vector>

 using namespace std;

 // Element == -1 ? reset 0 !
 inline void resetElement(int &ival)
 {
     if (ival == -)
     {
         ival = ;
     }
 }

 // Element > 10 ? deal element!
 inline void dealElement(vector<int> &ivec, vector<int>::size_type index)
 {
     while (ivec[index] >= )
     {
         int temp = ivec[index];
         ivec[index] %= ;
         index--;
         resetElement(ivec[index]);
         ivec[index] += (temp / );
     }
 }

 // ivecR[index] * intR
 void multiplicationCompute(vector<int> &ivecA, unsigned int &pointPosA, const int &intR, const int &pointPosR)
 {
     vector<int>::size_type currIndex = ;
     unsigned int val = ;

     for (vector<int>::size_type index = ;  index != ivecA.size(); ++index)
     {
         if (ivecA[index] != -)
         {
             currIndex = index;
             val = ivecA[index] * intR;

             ivecA[index] = ;   //  +=

             while (val)
             {
                 resetElement(ivecA[currIndex]);
                 ivecA[currIndex] += (val % );
                 dealElement(ivecA, currIndex);
                 val /= ;
                 currIndex--;
             }
         }
     }
     pointPosA = pointPosA + pointPosR;
 }

 int main(int argc, char *argv[])
 {

     string strR;
     unsigned int n;

     while (cin >> strR >> n)
     {
         unsigned int intR = ;
         vector<int> ivecR;
         vector<int> ivecA(, -);
         unsigned int pointPositionR = ;
         unsigned int pointPositionA = ;

         //将R转换为int型的vector，pointPositionR记录小数点位置（其值代表小数位的位数）
         for (string::size_type index = ; index != strR.size(); ++index)
         {
             if (strR[index] != '.')
             {
                 ivecR.push_back(strR[index] - '');
             }
             else
             {
                 pointPositionR = strR.size() -  - index;
             }
         }

         //将ivecR转换成intR
         for (vector<int>::size_type index = ; index != ivecR.size(); ++index)
         {
             intR = intR * + ivecR[index];
         }

         //将ivecR复制到ivecA，高位——低位存储，pointPositionA = pointPositionR
         for(int indexA = ivecA.size() - , indexR = ivecR.size() - ; indexA >=  && indexR >= ; --indexA, --indexR)
         {
             ivecA[indexA] = ivecR[indexR];
         }
         pointPositionA = pointPositionR;

         //if (n = 0)
         //{
         //    cout << 1 << endl;
         //    return 0;
         //}

         while (n >= )   //若 n = 1， 则 ivecA就是结果
         {
             multiplicationCompute(ivecA, pointPositionA, intR, pointPositionR);
             n--;
         }

         //纯小数,小数位超过ivecA的实数位则补0
         for (vector<int>::size_type index = ivecA.size() - ; index >= ivecA.size() - pointPositionA; --index)
         {
             if (ivecA[index] == -)
             {
                 ivecA[index] = ;
             }

         }

         //后缀0处理
         for (int index = ivecA.size() - ; index >=  && ivecA[index] == ; --index)
         {
             ivecA[index] = -;
         }

         vector<int>::size_type indexBegin = ;
         while (indexBegin != ivecA.size() && ivecA[indexBegin] == -)
         {
             indexBegin++;
         }

         if (indexBegin == ivecA.size())
         {
             cout <<  << endl;
         }
         else
         {
             for(vector<int>::size_type index = indexBegin; index != ivecA.size(); ++index)
             {
                 if (ivecA[index] != -)
                 {
                     if (index == ivecA.size() - pointPositionA)
                     {
                         cout << ".";
                     }
                     cout << ivecA[index];
                 }
             }
             cout << endl;
         }
     }
     return ;
 }