【poj】1001

【题目】

Exponentiation
Time Limit: 500MS Memory Limit: 10000K
Total Submissions: 123707 Accepted: 30202
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
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 */

{

...

}

----------------------------------------------------------------------------------------------------------------------------------------------------------

这道题是我真正意义上的第一道题。所以写的很乱。估计再过上一段时间后连自己都看不懂。
大概思路：因为没有任何一种数据类型能够容纳这种高精度运算的结果。所以用数组来储存数据。求幂的实质就是n-1次乘法运算。运算之前把对字符串进行处理（提取小数点，同时记录指数），转化为整形数组。值得注意的是，要在整形数组后面开始储存。比如储存1234，是a[MAX-1]=4;a[MAX-2]=3;..这样有助于乘法运算的时候向前进一位。运算过程结束后再转化为字符串。重新加入小数点。
这一题做了很久很久，走了不少弯路，也就收货了一些经验：
1.代码的书写很重要。最好能形成层层缩进的结构。这样美观大方修改起来十分方便。
2.在写代码之前最好能够先详细构思一下。也就是所谓的建模。不要一有idea就马上动笔写下来。这次我就是很快把核心部分写了下来，却因为没有一个完整的架构。修修补补花了大量的时间。
3.审题。一开始看错题目、、、、满满的都是泪啊。
4.测试的时候没有进行全面的考虑。后期引用了这位兄弟的测试数据才ac。http://www.cnblogs.com/lililqth/p/3187758.html

 #include<stdio.h>
 #include<stdlib.h>
 #include<string.h>
 #include<math.h>
 #define MAX 500
 int pows(char [],char [],int ,int []);   //高精度计算pow
 char *deal(char [],int ,int );    //处理计算好的字符串。
 int find(char []);     //寻找小数点所在位置,
 int cf(int [],int ,int [],int );  //高精度乘法
 int main(){
 char ins[MAX],des[MAX],*res;
 int n,index,len=;
 int temp[MAX];
  while(scanf("%s%d",ins,&n)!=EOF)
  {

    index=find(ins);
    memset(temp,,*MAX);
    len=pows(ins,des,n,temp);
    if(len!=)
     {
       res=deal(des,len,temp[MAX-]);           //传递指数
       des[MAX-]='\0';   //给倒数第二位加上字符串结束符
       printf("%s\n",res);
      }
     else return ;

  }
 }
 int find(char des[MAX])
 {
   int i=,index=-;
    for(i=;i<=strlen(des);i++)
     if(des[i]=='.'){
       index=i;
       return index;}
   return -; //默认没有找到小数点
 }
 char *deal(char des[],int len,int en){
 int i,ts=,zhi=,k=;
 //重新加入小数点
 zhi=MAX--(-en);   //小数点位置
  if((-en)==len)              {                          //-,小数点在刚好在第一位
    des[zhi]='.';
    return &des[zhi];       }
  else if((-en)>len)          {                          //二，数值小于1的情况，0.0xx；
      for(i=zhi;i<MAX--len;i++)
         des[i]='';
         des[zhi]='.';
         return &des[zhi];  }
  else if(en==)                                         //三，若此为整数，则直接返回字符串值
     return &des[MAX--len];
  else
  {                                                      //四，数值大于1的情况
    for(i=MAX--len;i<=zhi;i++)
      des[i-]=des[i];           //将小数点所在位置的前方往左挪一位。
    des[zhi]='.';
    return &des[MAX--len];
  }
 }

 int pows(char ins[MAX],char des[MAX],int n,int temp[MAX])
 {
   int t2[MAX]={};
   int i=,index=-,k=,m=,ji=,h=,kj=;
   int len=strlen(ins);
   index=find(ins);
   m=len;
   if(n==)
   {   //n=0
   for(i=;i<=len-;i++)
       if(ins[i]!=''){  //这个数不等于0
         temp[MAX-]=;
         temp[MAX-]=;
         break;       }
       else return ;   //不可以计算0的0次幂
   }
   else if(n==)
   {        //n=1
     for(i=;i<=len-;i++)    //从第一个位置开始遍历，检查前面是否有无意义的零
      if(ins[i]!='')
        break;
      if(i==len)
       {   //整个字符串全为0
           m=;
           temp[MAX-]=;  //表明这是一个整数
       }
      else
       {   //前面有无意义的0,此处包含无0的情况
           m=len-i-;
            //复制小数点之后的
           for(kj=MAX-,h=len-;h>index;h--,kj--)
             temp[kj]=ins[h]-;
           temp[MAX-]=-(len-index-);  //记录指数
            //复制小数点之前的
           for(k=h-;k>=i;kj--,k--)
             temp[kj]=ins[k]-;
       }
     for(i=len-,k=;i>=;i--) { //从后面开始扫描有没有无意义的0
       if(ins[i]!='')
         break;
         k++;                    } //计算有多少个0
     if(i<len-)
       {  //后面有无意义的0
          if(ins[i]=='.')
            { //1.00样式
              m -=k;
              for(h=MAX-;h>=MAX--m;h--)
                temp[h]=temp[h-k];
              temp[MAX-]=;   //标记为整数
            }
          else
            { //1.**00的样式
              m -=k;
              for(h=MAX-;h>=MAX--m;h--)
                temp[h]=temp[h-k];
              temp[MAX-] +=k;  //修改指数
            }
       }
   }
   else
   {         //n>=2
     if(index==-)
     {           //一。整数，没有找到小数点
       for(i=;i<=len-;i++)   {
         temp[MAX--len+i]=ins[i]-;
         t2[MAX--len+i]=ins[i]-;
                               }
     }
     else
     {           //二找到小数点
        if(index==)
         {  //处理形式为 。**的形式的实数
           for(i=len;i>=;i--)
              ins[i]=ins[i-];
           ins[]='';
           len++;
         }
        i=len-;
        while(ins[i]=='')  i--;   //从最后一个字符开始检查，检查最后是否带有无意义的0
        if(i<len-)
        {         //******后面带有无意义的0          

          if(ins[i]=='.')
          {               //-----1.00的形式
            len=i;    //连同小数点一起抛弃
            index=-; //将该数标记为整数
            for(i=;i<=len-;i++)
            {    //复制到整形数组中
              temp[MAX--len+i]=ins[i]-;
              t2[MAX--len+i]=ins[i]-;
            }
          }
          else
          {               //------1.**000的形式
            len=i+;
             for(i=;i<=index-;i++)     {         //用两个for循环将字符串转换为整形数组，并且要将从右边开始写入
               temp[MAX--len+i]=ins[i]-;         //从整形数组的倒数第三位开始储存
               t2[MAX--len+i]=ins[i]-; }
                                           //跳过小数点
             for(k=index+;k<=len-;k++,i++){
               temp[MAX--len+i]=ins[k]-;
               t2[MAX--len+i]=ins[k]-;    }
          }
        }
        else
        {         //******后面没有无意义的0              

           for(i=;i<=index-;i++)      {         //用两个for循环将字符串转换为整形数组，并且要将从右边开始写入
              temp[MAX--len+i]=ins[i]-;         //从整形数组的倒数第三位开始储存
              t2[MAX--len+i]=ins[i]-;}

           for(k=index+;k<=len-;k++,i++) {   //跳过小数点
             temp[MAX--len+i]=ins[k]-;
             t2[MAX--len+i]=ins[k]-;    }
        }
     }
     //在数组的最后一位记录这两个数的指数
     if(index==-)
     {      //如果为整数则将该指数部分置为0
     temp[MAX-]=;
     t2[MAX-]=;
     k=len;
     m=len;
     }
     else
     {   //不为整数
     temp[MAX-]=index-len+;
     t2[MAX-]=index-len+;
     k=len-;
     m=len-;
     }
    for(i=;i<n-;i++)     //pow的核心
     {    //需要n-1次乘法
        cf(temp,m,t2,k);     //cf返回temp数组中所含数的长度
        for(ji=;ji<=MAX-;ji++)
         {   //计算temp中的数的长度
            if(temp[ji]!=){
             m=MAX-ji-;
            break;   }
         }
     }
   }
   //重新将字符转换为数值
 for(i=MAX-;i>=MAX--m+;i--)   //从整形数组倒数第三位开始复制到字符串的倒数第三位
 des[i]=temp[i]+;
 return m;     //返回字符串的长度
 }
 int cf(int temp[MAX],int m,int src[MAX],int k){
      int t[MAX]={};
      int i=,num=;
      int sr=,tmp=MAX-,j=sr;
      temp[MAX-]=; //防止k在边界时溢出.在倒数第二位储存0
      src[MAX-]=;
   // 用两个for循环来完成两个数的相乘
   for(sr=MAX-;sr>=MAX-m-;sr--)        //数组的倒数第三位储存数的最低位
   {
    for(tmp=MAX-,j=sr;tmp>=MAX--m;tmp--,j--)  //src从个位开始每位乘以temp中的每一位 //之所以使j=sr--我们在计算两数相乘时总会将下一行的数向左挪一位。
     t[j] +=src[sr]*temp[tmp];
   }
   //将t复制到temp中
   for(i=MAX-;i>=sr-m+;i--)
     temp[i]=t[i];
   for(i=MAX-;i>=sr-m;i--)
   {   // 处理temp中的数，过十进一，每一位只保留个位,需要注意的是有可能是进百位。故要把i提前到temp左端的前两格
     temp[i] +=num;
     num=  (temp[i]-temp[i]%)/; //保存当前一位的十位数和百位数.如128保留12；
     temp[i]=temp[i]%;     //进位后，只保存个位数
   }
    temp[MAX-] +=src[MAX-];  //处理指数部分的相乘
   return ;
 }