POJ1001 且适合带小数点大数的幂（R^N）

/** \function calculator R^N
 *
 * \param
 * \param
 * \return
 *
 */

#include <iostream>
#include <vector>
#include <string>
using namespace std;


//big number multiplication.
//str1 is the first number.
//str2 is the second number.
//return str1*str2
string BigNumberMulti(const string& str1,const string& str2)
{

        string product_str;
        vector<int> product_number,product_number_reverse;

        //reset every member of vector product_number to 0.
        int i=0,limit=str1.size()+str2.size()-1;
        for(i=0;i!=limit;i++)
        {
            product_number.push_back(0);
        }

        //multiplication content and the product is stored in product_number.
        string::const_iterator iter_str1,iter_str2;
        vector<int>::iterator iter_int;
        vector<int>::difference_type bit_move=0;//multiplication move one bit by once

        for(iter_str2=str2.begin();iter_str2!=str2.end();iter_str2++)
        {

            for(iter_str1=str1.begin(),iter_int=product_number.begin()+bit_move;iter_str1!=str1.end();iter_str1++,iter_int++)
            {

                *iter_int=*iter_int+(*iter_str2-'0')*(*iter_str1-'0');
            }
            bit_move++;
        }

        //transform ints to chars,product_number to product_str.
        int remainder_now=0,remainder_pre=0;
        vector<int>::reverse_iterator reverse_iter_int;
        for(reverse_iter_int=product_number.rbegin();reverse_iter_int!=product_number.rend();reverse_iter_int++)
        {
            remainder_now=(*reverse_iter_int+remainder_pre)%10;
            product_number_reverse.push_back(remainder_now);
            remainder_pre=(*reverse_iter_int+remainder_pre)/10;
        }
        while(remainder_pre!=0)
        {
            product_number_reverse.push_back(remainder_pre%10);
            remainder_pre=remainder_pre/10;
        }
        for(reverse_iter_int=product_number_reverse.rbegin();reverse_iter_int!=product_number_reverse.rend();reverse_iter_int++)
        {
            product_str.push_back('0'+*reverse_iter_int);
        }

        return product_str;

}

/** \round calculator R^n
 *
 * \param int n
 * \return string
 *
 */
string power(const string& R_int,int n)
{
    if(n==0)
    {
        string str0("1");
        return str0;
    }
    else
    {
        string str1=power(R_int,n/2);
        if(n%2==0)return BigNumberMulti(str1,str1);
        else return BigNumberMulti(BigNumberMulti(str1,str1),R_int);
    }
}

/** \function transform R_double to R_int
 *
 * \param
 * \param
 * \return
 *
 */
class Two_Var{
public:
    string R_int;
    int point_steps;
};

Two_Var R_transform(const string& R_double)
{
    Two_Var temp;
    string::const_iterator iter;

    int point_position,po_pre=0;
    for(iter=R_double.begin();iter!=R_double.end();iter++)
    {
        if(*iter=='.') break;
        po_pre++;
    }
    point_position=R_double.size()-(po_pre+1);
    if(point_position<1) point_position=0;
    temp.point_steps=point_position;

    string str_int;
    for(iter=R_double.begin();iter!=R_double.end();iter++)
    {
        if(*iter!='.'&&*iter!='0') break;
    }
    for(;iter!=R_double.end();iter++)
        if(*iter!='.') str_int.push_back(*iter);
    temp.R_int=str_int;

    return temp;
}

/** \add point(.) in N_int,meanwhile delete 0 at the end
 *
 * \param1 int type of the product
 * \param2 the position to insert point(.)
 * \return final perfect product
 *
 */

string add_0andpoint(const string& product_str,int pointsteps)
{
    string final_str;
    string::const_iterator iter,iter1;
    int flag=0;//0 shows have not added point,1 shows have added point.
    if(product_str.size()>pointsteps)
    {
        iter1=product_str.begin()+product_str.size()-pointsteps;
        for(iter=product_str.begin();iter!=product_str.end();)
        {
            if(flag==0&&iter==iter1)
            {
                final_str.push_back('.');
                flag=1;
            }

            else
            {
                final_str.push_back(*iter);
                iter++;
            }
        }
    }
    else
    {
        final_str.push_back('.');
        flag=1;
        int i=0;
        for(i=1;i<pointsteps-product_str.size()+1;i++)
            final_str.push_back('0');
        for(iter=product_str.begin();iter!=product_str.end();iter++)
            final_str.push_back(*iter);

    }


    //delete zeros of the end
    string::reverse_iterator iter2,iter3;
    for(iter2=final_str.rbegin();iter2!=final_str.rend();iter2++)
        if(*iter2!='0') break;
    for(iter3=final_str.rbegin();iter3!=final_str.rend();iter3++)
        if(*iter3=='.') break;
    if(iter3==final_str.rend()) return final_str;
    string::difference_type zeros_mount=iter2-final_str.rbegin();
    if(iter3>iter2)
        final_str.erase(final_str.size()-zeros_mount,zeros_mount);
    else if(iter3==iter2)
        final_str.erase(final_str.size()-zeros_mount-1,zeros_mount+1);
    if(final_str.size()==0) final_str="0";//if final_str is null,let it be "0";



    return final_str;


}




int main()
{
    int N;//power
    string R_double;//str input,the R of R^N
    Two_Var twovar;
    while (cin>>R_double>>N)
    {
        twovar=R_transform(R_double);
        cout<<add_0andpoint(power(twovar.R_int,N),N*twovar.point_steps)<<endl;
    }

    return 0;
}