UVa623:500!

题目大意

简单粗暴，给定正整数n，计算 n! 并输出，这里n最大为1000。

Solution1(naive)

因为阶乘的数值会非常大，所以需要大整数类的支持，一个简单粗暴的想法是利用java中的BigInteger类，这个类已经实现了大整数的所有操作。这种做法很简单直接，但运行速度会稍慢。

AC-Code(Java)

Time:450ms

import java.util.Scanner;
import java.math.BigInteger;
public class Main {
    
    static final int maxn = 1000 + 10;
    static BigInteger dp[] = new BigInteger[maxn];
    
    public static BigInteger fact(int x) {
        if(!dp[x].equals(BigInteger.ZERO))
            return dp[x];
        BigInteger bx = BigInteger.valueOf(x);
        dp[x] = bx.multiply(fact(x-1));
        return dp[x];
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner s = new Scanner(System.in);
        for(int i=1;i<maxn;i++)
            dp[i] = BigInteger.ZERO;
        dp[0] = BigInteger.ONE;
        while(s.hasNext()) {
            int n = s.nextInt();
            System.out.println(n + "!");
            System.out.println(fact(n));
        }
        s.close();

    }

}

Solution2

而如果追求更高的效率，还是要采用c++，可以用int数组手动模拟乘法的过程。

代码中carry表示进向更高位的数值，len表示数字的长度。

AC-Code(C++)

Time:200ms

#include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <set>
#include <vector>
#include <cmath>
#include <climits>
#include <ctime>

using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const int maxn = 1000 + 10;

int number[maxn];


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

//    freopen("input.txt", "r", stdin);
    
    int n,len;
    while(scanf("%d",&n)==1){
        memset(number, 0, sizeof(number));
        number[0] = 1;
        len = 1;
        for(int i=2;i<=n;i++){
            int carry = 0;
            for(int j=0;j<len;j++){
                number[j] *= i;
                number[j] += carry;
                carry  = number[j] / 10000; // stored 4 digit in each unit of number
                number[j] %= 10000;
            }
            if(carry > 0)
                number[len++] = carry;
        }
        printf("%d!\n",n);
        printf("%d",number[len-1]);
        for(int i=len-2;i>=0;i--)
            printf("%04d",number[i]);
        printf("\n");
    }



    return 0;
}

Solution3

上面这个解法相对于第一个解法已经有了较大的性能提升，但存在着大量的重复计算。比如说计算1000!的时候，完全可以由 1000*999! 得出，而不必从头开始计算。因此，我们可以采取用空间换时间的策略，记录下所有的中间结果，进一步提高程序的运行效率。

这里将number改为一个二维数组，将len改为一维数组。

AC-Code(C++)

Time:20ms

#include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <set>
#include <vector>
#include <cmath>
#include <climits>
#include <ctime>

using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
const int maxn = 1000 + 10;

int number[maxn][maxn];
int len[maxn];


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

//    freopen("input.txt", "r", stdin);
    
    int n;
    number[0][0] = 1;
    len[0] = 1;
    for(int i=1;i<=1000;i++){
        memcpy(&number[i][0], &number[i-1][0], len[i-1] * sizeof(int));
        len[i] = len[i-1];
        int carry = 0;
        for(int j=0;j<len[i-1];j++){
            number[i][j] *= i;
            number[i][j] += carry;
            carry  = number[i][j] / 10000; // stored 4 digit in each unit of number
            number[i][j] %= 10000;
        }
        if(carry > 0)
            number[i][len[i]++] = carry;
    }
    while(scanf("%d",&n)==1){
        printf("%d!\n",n);
        printf("%d",number[n][len[n]-1]);
        for(int i=len[n]-2;i>=0;i--)
            printf("%04d",number[n][i]);
        printf("\n");
    }



    return 0;
}