hdu 1042 N!

题目连接

http://acm.hdu.edu.cn/showproblem.php?pid=1042

N!

Description

Given an integer N(0 ≤ N ≤ 10000), your task is to calculate N!

Input

One N in one line, process to the end of file.

Output

For each N, output N! in one line.

Sample Input

1
2
3

Sample Output

1
2
6

用斯特林公式$\begin{align}\large{}n! \approx \large{}\sqrt{2 \pi n}({\frac{n}{e}})^n\end{align}$估计一下阶乘位数，

其余没啥说的，测模板。。

  1 #include<algorithm>

  2 #include<iostream>

  3 #include<istream>

  4 #include<ostream>

  5 #include<cstdlib>

  6 #include<cstring>

  7 #include<cassert>

  8 #include<cstdio>

  9 #include<string>

 10 using std::max;

 11 using std::cin;

 12 using std::cout;

 13 using std::endl;

 14 using std::swap;

 15 using std::string;

 16 using std::istream;

 17 using std::ostream;

 18 struct BigN {

 19     typedef unsigned long long ull;

 20     static const int Max_N = 36000;

 21     int len, data[Max_N];

 22     BigN() { memset(data, 0, sizeof(data)), len = 0; }

 23     BigN(const int num) {

 24         memset(data, 0, sizeof(data));

 25         *this = num;

 26     }

 27     BigN(const char *num) {

 28         memset(data, 0, sizeof(data));

 29         *this = num;

 30     }

 31     void cls() { len = 0, memset(data, 0, sizeof(data)); }

 32     BigN& clean(){ while (len > 1 && !data[len - 1]) len--;  return *this; }

 33     string str() const {

 34         string res = "";

 35         for (int i = len - 1; ~i; i--) res += (char)(data[i] + '0');

 36         if (res == "") res = "0";

 37         res.reserve();

 38         return res;

 39     }

 40     BigN operator = (const int num) {

 41         int j = 0, i = num;

 42         do data[j++] = i % 10; while (i /= 10);

 43         len = j;

 44         return *this;

 45     }

 46     BigN operator = (const char *num) {

 47         len = strlen(num);

 48         for (int i = 0; i < len; i++) data[i] = num[len - i - 1] - '0';

 49         return *this;

 50     }

 51     BigN operator + (const BigN &x) const {

 52         BigN res;

 53         int n = max(len, x.len) + 1;

 54         for (int i = 0, g = 0; i < n; i++) {

 55             int c = data[i] + x.data[i] + g;

 56             res.data[res.len++] = c % 10;

 57             g = c / 10;

 58         }

 59         while (!res.data[res.len - 1]) res.len--;

 60         return res;

 61     }

 62     BigN operator * (const BigN &x) const {

 63         BigN res;

 64         int n = x.len;

 65         res.len = n + len;

 66         for (int i = 0; i < len; i++) {

 67             for (int j = 0, g = 0; j < n; j++) {

 68                 res.data[i + j] += data[i] * x.data[j];

 69             }

 70         }

 71         for (int i = 0; i < res.len - 1; i++) {

 72             res.data[i + 1] += res.data[i] / 10;

 73             res.data[i] %= 10;

 74         }

 75         return res.clean();

 76     }

 77     BigN operator * (const int num) const {

 78         BigN res;

 79         res.len = len + 1;

 80         for (int i = 0, g = 0; i < len; i++) res.data[i] *= num;

 81         for (int i = 0; i < res.len - 1; i++) {

 82             res.data[i + 1] += res.data[i] / 10;

 83             res.data[i] %= 10;

 84         }

 85         return res.clean();

 86     }

 87     BigN operator - (const BigN &x) const {

 88         assert(x <= *this);

 89         BigN res;

 90         for (int i = 0, g = 0; i < len; i++) {

 91             int c = data[i] - g;

 92             if (i < x.len) c -= x.data[i];

 93             if (c >= 0) g = 0;

 94             else g = 1, c += 10;

 95             res.data[res.len++] = c;

 96         }

 97         return res.clean();

 98     }

 99     BigN operator / (const BigN &x) const {

100         return *this;

101     }

102     BigN operator += (const BigN &x) { return *this = *this + x; }

103     BigN operator *= (const BigN &x) { return *this = *this * x; }

104     BigN operator -= (const BigN &x) { return *this = *this - x; }

105     BigN operator /= (const BigN &x) { return *this = *this / x; }

106     bool operator <  (const BigN &x) const {

107         if (len != x.len) return len < x.len;

108         for (int i = len - 1; ~i; i--) {

109             if (data[i] != x.data[i]) return data[i] < x.data[i];

110         }

111         return false;

112     }

113     bool operator >(const BigN &x) const { return x < *this; }

114     bool operator<=(const BigN &x) const { return !(x < *this); }

115     bool operator>=(const BigN &x) const { return !(*this < x); }

116     bool operator!=(const BigN &x) const { return x < *this || *this < x; }

117     bool operator==(const BigN &x) const { return !(x < *this) && !(x > *this); }

118 };

119 istream& operator >> (istream &in, BigN &x) {

120     string src;

121     in >> src;

122     x = src.c_str();

123     return in;

124 }

125 ostream& operator << (ostream &out, const BigN &x) {

126     out << x.str();

127     return out;

128 }

129 int main() {

130 #ifdef LOCAL

131     freopen("in.txt", "r", stdin);

132     freopen("out.txt", "w+", stdout);

133 #endif

134     int n;

135     while (~scanf("%d", &n)) {

136         BigN res = 1;

137         if (0 == n || 1 == n) {

138             puts("1");

139             continue;

140         }

141         for (int i = 1; i <= n; i++) res *= i;

142         cout << res << endl;

143     }

144     return 0;

145 }

View Code