Hdu 4762 网络赛 高精度大数模板+概率

注意题目中的这句话he put the strawberries on the cake randomly one by one，第一次选择草莓其实有N个可能，以某一个草莓为开头，然后顺序的随机摆放，所以最后的概率为n/m^(n-1)，最后通过大数模板搞定该题的化简。

C++代码

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<iomanip>
 #include<algorithm>
 using namespace std;
 #define MAXN 9999
 #define MAXSIZE 10
 #define DLEN 4

 class BigNum
 {
 private:
     int a[];    //可以控制大数的位数
     int len;       //大数长度
 public:
     BigNum(){ len = ;memset(a,,sizeof(a)); }   //构造函数
     BigNum(const int);       //将一个int类型的变量转化为大数
     BigNum(const char*);     //将一个字符串类型的变量转化为大数
     BigNum(const BigNum &);  //拷贝构造函数
     BigNum &operator=(const BigNum &);   //重载赋值运算符，大数之间进行赋值运算

     friend istream& operator>>(istream&,  BigNum&);   //重载输入运算符
     friend ostream& operator<<(ostream&,  BigNum&);   //重载输出运算符

     BigNum operator+(const BigNum &) const;   //重载加法运算符，两个大数之间的相加运算
     BigNum operator-(const BigNum &) const;   //重载减法运算符，两个大数之间的相减运算
     BigNum operator*(const BigNum &) const;   //重载乘法运算符，两个大数之间的相乘运算
     BigNum operator/(const int   &) const;    //重载除法运算符，大数对一个整数进行相除运算

     BigNum operator^(const int  &) const;    //大数的n次方运算
     int    operator%(const int  &) const;    //大数对一个int类型的变量进行取模运算
     bool   operator>(const BigNum & T)const;   //大数和另一个大数的大小比较
     bool   operator>(const int & t)const;      //大数和一个int类型的变量的大小比较

     void print();       //输出大数
 };
 BigNum::BigNum(const int b)     //将一个int类型的变量转化为大数
 {
     int c,d = b;
     len = ;
     memset(a,,sizeof(a));
     while(d > MAXN)
     {
         c = d - (d / (MAXN + )) * (MAXN + );
         d = d / (MAXN + );
         a[len++] = c;
     }
     a[len++] = d;
 }
 BigNum::BigNum(const char*s)     //将一个字符串类型的变量转化为大数
 {
     int t,k,index,l,i;
     memset(a,,sizeof(a));
     l=strlen(s);
     len=l/DLEN;
     if(l%DLEN)
         len++;
     index=;
     for(i=l-;i>=;i-=DLEN)
     {
         t=;
         k=i-DLEN+;
         if(k<)
             k=;
         for(int j=k;j<=i;j++)
             t=t*+s[j]-'';
         a[index++]=t;
     }
 }
 BigNum::BigNum(const BigNum & T) : len(T.len)  //拷贝构造函数
 {
     int i;
     memset(a,,sizeof(a));
     for(i =  ; i < len ; i++)
         a[i] = T.a[i];
 }
 BigNum & BigNum::operator=(const BigNum & n)   //重载赋值运算符，大数之间进行赋值运算
 {
     int i;
     len = n.len;
     memset(a,,sizeof(a));
     for(i =  ; i < len ; i++)
         a[i] = n.a[i];
     return *this;
 }
 istream& operator>>(istream & in,  BigNum & b)   //重载输入运算符
 {
     char ch[MAXSIZE*];
     int i = -;
     in>>ch;
     int l=strlen(ch);
     int count=,sum=;
     for(i=l-;i>=;)
     {
         sum = ;
         int t=;
         for(int j=;j<&&i>=;j++,i--,t*=)
         {
             sum+=(ch[i]-'')*t;
         }
         b.a[count]=sum;
         count++;
     }
     b.len =count++;
     return in;

 }
 ostream& operator<<(ostream& out,  BigNum& b)   //重载输出运算符
 {
     int i;
     cout << b.a[b.len - ];
     for(i = b.len -  ; i >=  ; i--)
     {
         cout.width(DLEN);
         cout.fill('');
         cout << b.a[i];
     }
     return out;
 }

 BigNum BigNum::operator+(const BigNum & T) const   //两个大数之间的相加运算
 {
     BigNum t(*this);
     int i,big;      //位数
     big = T.len > len ? T.len : len;
     for(i =  ; i < big ; i++)
     {
         t.a[i] +=T.a[i];
         if(t.a[i] > MAXN)
         {
             t.a[i + ]++;
             t.a[i] -=MAXN+;
         }
     }
     if(t.a[big] != )
         t.len = big + ;
     else
         t.len = big;
     return t;
 }
 BigNum BigNum::operator-(const BigNum & T) const   //两个大数之间的相减运算
 {
     int i,j,big;
     bool flag;
     BigNum t1,t2;
     if(*this>T)
     {
         t1=*this;
         t2=T;
         flag=;
     }
     else
     {
         t1=T;
         t2=*this;
         flag=;
     }
     big=t1.len;
     for(i =  ; i < big ; i++)
     {
         if(t1.a[i] < t2.a[i])
         {
             j = i + ;
             while(t1.a[j] == )
                 j++;
             t1.a[j--]--;
             while(j > i)
                 t1.a[j--] += MAXN;
             t1.a[i] += MAXN +  - t2.a[i];
         }
         else
             t1.a[i] -= t2.a[i];
     }
     t1.len = big;
     while(t1.a[len - ] ==  && t1.len > )
     {
         t1.len--;
         big--;
     }
     if(flag)
         t1.a[big-]=-t1.a[big-];
     return t1;
 }

 BigNum BigNum::operator*(const BigNum & T) const   //两个大数之间的相乘运算
 {
     BigNum ret;
     int i,j,up;
     int temp,temp1;
     for(i =  ; i < len ; i++)
     {
         up = ;
         for(j =  ; j < T.len ; j++)
         {
             temp = a[i] * T.a[j] + ret.a[i + j] + up;
             if(temp > MAXN)
             {
                 temp1 = temp - temp / (MAXN + ) * (MAXN + );
                 up = temp / (MAXN + );
                 ret.a[i + j] = temp1;
             }
             else
             {
                 up = ;
                 ret.a[i + j] = temp;
             }
         }
         if(up != )
             ret.a[i + j] = up;
     }
     ret.len = i + j;
     while(ret.a[ret.len - ] ==  && ret.len > )
         ret.len--;
     return ret;
 }
 BigNum BigNum::operator/(const int & b) const   //大数对一个整数进行相除运算
 {
     BigNum ret;
     int i,down = ;
     for(i = len -  ; i >=  ; i--)
     {
         ret.a[i] = (a[i] + down * (MAXN + )) / b;
         down = a[i] + down * (MAXN + ) - ret.a[i] * b;
     }
     ret.len = len;
     while(ret.a[ret.len - ] ==  && ret.len > )
         ret.len--;
     return ret;
 }
 int BigNum::operator %(const int & b) const    //大数对一个int类型的变量进行取模运算
 {
     int i,d=;
     for (i = len-; i>=; i--)
     {
         d = ((d * (MAXN+))% b + a[i])% b;
     }
     return d;
 }
 BigNum BigNum::operator^(const int & n) const    //大数的n次方运算
 {
     BigNum t,ret();
     int i;
     if(n<)
         exit(-);
     if(n==)
         return ;
     if(n==)
         return *this;
     int m=n;
     while(m>)
     {
         t=*this;
         for( i=;i<<<=m;i<<=)
         {
             t=t*t;
         }
         m-=i;
         ret=ret*t;
         if(m==)
             ret=ret*(*this);
     }
     return ret;
 }
 bool BigNum::operator>(const BigNum & T) const   //大数和另一个大数的大小比较
 {
     int ln;
     if(len > T.len)
         return true;
     else if(len == T.len)
     {
         ln = len - ;
         while(a[ln] == T.a[ln] && ln >= )
             ln--;
         if(ln >=  && a[ln] > T.a[ln])
             return true;
         else
             return false;
     }
     else
         return false;
 }
 bool BigNum::operator >(const int & t) const    //大数和一个int类型的变量的大小比较
 {
     BigNum b(t);
     return *this>b;
 }

 void BigNum::print()    //输出大数
 {
     int i;
     cout << a[len - ];
     for(i = len -  ; i >=  ; i--)
     {
         cout.width(DLEN);
         cout.fill('');
         cout << a[i];
     }
     cout << endl;
 }

 int main()
 {
     int t;
     BigNum m , n ;
     int i , mm , nn; //定义大数对象
     cin>>t;
     while(t--){
         cin>>mm>>nn;
         m = ;
         for(i = ;i<=nn-;i++){
             m = m * mm;
         }
         for(i = nn ; i>= ; i--){
             if(m%i ==  && nn%i == ){
                  m = m / i;
                  nn = nn / i;
                  cout<<nn<<"/"<<m<<endl;
                  break;
             }
         }
     }
     return ;
 }

Java代码

 import java.math.BigInteger;
 import java.util.Scanner;

 public class Main {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
             Scanner cin = new Scanner(System.in);
             int a = cin.nextInt();
             for(int i =1 ; i<=a ;i++){
                 BigInteger m, c;
                 int n ;
                 m = cin.nextBigInteger();
                 n = cin.nextInt();
                 m = m.pow(n - 1);
                 BigInteger p = BigInteger.valueOf(n);
                 c = m.gcd(p);
                 System.out.println(p.divide(c)+"/"+m.divide(c));
             }

     }

 }