HDU1042 N!

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1042

#include<iostream>
#include<stdio.h>
#include<string>
#include<iomanip>
#include<algorithm>
using namespace std;

const int MAX_GROUPS = 10000;//最多万组，每组最多位整数，即最多可容纳万位整数
const int MAXN = 9999;//每组的上限值
const int GROUP_LEN = 4;//每组的最大长度

class BigInteger
{
private:
    int data[MAX_GROUPS];
    int len;
    void init()
    {
        memset(data,0,sizeof(data));
    }
public:
    BigInteger()
    {
        init();
        len = 0;
    }
    BigInteger(const int b);
    BigInteger(const BigInteger &);

    bool operator > (const BigInteger&)const;
    BigInteger & operator=(const BigInteger &);
    BigInteger & add(const BigInteger &);
    BigInteger & sub(const BigInteger &);
    BigInteger operator+(const BigInteger &) const;
    BigInteger operator-(const BigInteger &) const;
    BigInteger operator*(const BigInteger &) const;
    BigInteger operator/(const int &) const;
    void print();
};
BigInteger::BigInteger(const int num)
{
    int res,tmp = num;
    len = 0;
    init();
    while(tmp > MAXN)
    {
        res = tmp - tmp / (MAXN + 1) * (MAXN + 1);
        tmp = tmp / (MAXN + 1);
        data[len++] = res;
    }
    data[len++] = tmp;
}
BigInteger::BigInteger(const BigInteger & rhs) : len(rhs.len)
{
    int i;
    init();
    for(i = 0 ; i < len ; i++)
    {
        data[i] = rhs.data[i];
    }
}
bool BigInteger::operator > (const BigInteger &rhs)const
{
    int ln;
    if(len > rhs.len)
    {
        return true;
    }
    else if(len < rhs.len)
    {
        return false;
    }
    else if(len == rhs.len)
    {
        ln = len - 1;
        while(data[ln] == rhs.data[ln] && ln >= 0) 
        {
            ln--;
        }
        if(ln >= 0 && data[ln] > rhs.data[ln]) 
        {
            return true;
        }
        else 
        {
            return false;
        }
    }

}

BigInteger & BigInteger::operator = (const BigInteger &rhs)
{
    init();
    len = rhs.len;
    for(int i = 0 ; i < len ; i++)
    {
        data[i] = rhs.data[i];
    }
    return *this;
}
BigInteger& BigInteger::add(const BigInteger &rhs)
{
    int i,nLen;

    nLen = rhs.len > len ? rhs.len : len;
    for(i = 0 ; i < nLen ; i++)
    {
        data[i] = data[i] + rhs.data[i];
        if(data[i] > MAXN)
        {
            data[i + 1]++;
            data[i] = data[i] - MAXN - 1;
        }
    }
    if(data[nLen] != 0) 
    {
        len = nLen + 1;
    }
    else 
    {
        len = nLen;
    }

    return *this;
}
BigInteger & BigInteger::sub(const BigInteger &rhs)
{
    int i,j,nLen;
    if (len > rhs.len)
    {
        for(i = 0 ; i < nLen ; i++)
        {
            if(data[i] < rhs.data[i])
            {
                j = i + 1;
                while(data[j] == 0) j++;
                data[j]--;
                --j;
                while(j > i)
                {
                    data[j] += MAXN;
                    --j;
                }
                data[i] = data[i] + MAXN + 1 - rhs.data[i];
            }
            else 
            {
                data[i] -= rhs.data[i];
            }
        }
        len = nLen;
        while(data[len - 1] == 0 && len > 1) 
        {
            --len;    
        }
    }
    else if (len == rhs.len)
    {
        for(i = 0 ; i < len ; i++)
        {
            data[i] -= rhs.data[i];
        }
        while(data[len - 1] == 0 && len > 1) 
        {
            --len;    
        }
    }
    return *this;
}
BigInteger BigInteger::operator+(const BigInteger & n) const 
{
    BigInteger a = *this;
    a.add(n);
    return a;
}
BigInteger BigInteger::operator-(const BigInteger & T) const
{
    BigInteger b = *this;
    b.sub(T);
    return b;
}
BigInteger BigInteger::operator * (const BigInteger &rhs) const
{
    BigInteger result;
    int i,j,up;
    int temp,temp1;

    for(i = 0; i < len; i++)
    {
        up = 0;
        for(j = 0; j < rhs.len; j++)
        {
            temp = data[i] * rhs.data[j] + result.data[i + j] + up;
            if(temp > MAXN)
            {
                temp1 = temp - temp / (MAXN + 1) * (MAXN + 1);
                up = temp / (MAXN + 1);
                result.data[i + j] = temp1;
            }
            else 
            {
                up = 0;
                result.data[i + j] = temp;
            }
        }
        if(up != 0)
        {
            result.data[i + j] = up;
        }
    }
    result.len = i + j;
    while(result.data[result.len - 1] == 0 && result.len > 1) result.len--;
    return result;
}
BigInteger BigInteger::operator/(const int & b) const
{
    BigInteger ret;
    int i,down = 0;

    for(i = len - 1 ; i >= 0 ; i--)
    {
        ret.data[i] = (data[i] + down * (MAXN + 1)) / b;
        down = data[i] + down * (MAXN + 1) - ret.data[i] * b;
    }
    ret.len = len;
    while(ret.data[ret.len - 1] == 0) ret.len--;
    return ret;
}
void BigInteger::print()
{
    int i;

    cout << data[len - 1];
    for(i = len - 2 ; i >= 0 ; i--)
    {
        cout.width(GROUP_LEN);
        cout.fill('0');
        cout << data[i];
    }
    cout << endl;
}
int main()
{
    int i,n;
    BigInteger result,num;

    while(scanf("%d",&n)!=EOF)
    {
        result = BigInteger(1);
        for(i = 2;i <= n; ++i)
        {
            num = BigInteger(i);
            result = result * num;
        }
        result.print();
    }
    return 0;
}