HDU 1604 (数论)

此题感觉好难，比赛时推两个小时无果。。。幸得一大神博客，感觉太强大了，学的东西还有很多啊

赶紧收藏

这题的大意就是 给出一个数n, 找到它所有的因子， 然后把这些（因子的因子数）的立方和求出来。

题目的时限虽然很宽，但是数据很BT。首先，公式必须找出来。

证明如下：

先将n质因数分解成形如n = a ^m * b ^ p * c ^q *........;

那么要求的结果为函数g(x)的值;

我们以n有2个质因数为例子；

g(n) = g(a ^m  *  b ^p ) ;

设求因子个数的立方的函数为f(x);

然后找到所有的因子并计算和;

g(a ^ m  *  b  ^ p ) = f( a ^ m * b ^ p ) + f( a ^ (m - 1) * b  ^  p ) + f( a ^ (m - 2) * b  ^ p ) +...... + f (a ^ 0 * b ^ p) +  f(a ^m * b ^ (p - 1)) +   f(a ^(m - 1) * b ^ (p - 1)) ......+ f(a ^ 0 * b ^ (p - 1)) +...............+f(a ^ m * b ^ 0) + f(a ^ (m - 1) * b ^ 0) +.........f(a ^ 0 * b ^ 0);   ①式

注意 这个序列里有 （m + 1） * ( n  + 1 )  个数， 所有的因子都表示出来了；

我们再观察f(x)的性质， 可以发现一个很重要的性质，如果 x, y互质，那么f( x * y ) = f(x) * f(y);   这个称为积性函数， 实际上自己观察规律就能找到这个性质；

我们再根据这个性质  就可以合并①式了；

g(a ^m  *  b ^p ) = (f(a ^m) + f(a ^ ( m - 1)) + f(a ^ (m - 2 ) ) + ..... + f(a ^ 0)) * (f(b ^p) + f(b ^ ( p - 1)) + f(b ^ (p - 2 ) ) + ..... + f(b ^ 0));

对于一个类似于x ^ y的因子数，答案是显而易见的 y + 1;

那么g(a ^m  *  b ^p )  = (1^3 + 2 ^ 3 + ..... + m ^ 3 + (m + 1)^ 3) * (1^3 + 2 ^ 3 + ..... + p ^ 3 + (p + 1)^ 3) ;

而立方和公式为 [(x * (x + 1)) / 2] ^ 2;

那么g(a ^m  *  b ^p ) = [((m  + 2)* (m + 1)) / 2] ^ 2  * [((p + 2) * (p+ 1)) / 2] ^ 2;

g(n) 就求出来了。

我们可以得到一个普遍规律了

如果一个合数能被分解为 a ^ m * b ^ n * c ^ p *.............(a, b, c ......均为素数, m, n, p.....均为自然数) 

那么题目要求的结果就是  [((m  + 2)* (m + 1)) / 2] ^ 2  * [((n + 2) * (n+ 1)) / 2] ^ 2 *  [((p + 2) * (p+ 1)) / 2] ^ 2 *.............

我的代码如下， 代码功底还很浅薄，写的比较丑，而且还用了1s多才过的 比较神奇的是用g++交会达到2s多， 而且用getchar() 优化输入也没降时间，很神奇

[cpp]  view plain copy

1. /* 
2. ID: sdj22251 
3. PROG: calfflac 
4. LANG: C++ 
5. */  
6. #include <iostream>  
7. #include <vector>  
8. #include <list>  
9. #include <map>  
10. #include <set>  
11. #include <deque>  
12. #include <queue>  
13. #include <stack>  
14. #include <bitset>  
15. #include <algorithm>  
16. #include <functional>  
17. #include <numeric>  
18. #include <utility>  
19. #include <sstream>  
20. #include <iomanip>  
21. #include <cstdio>  
22. #include <cmath>  
23. #include <cstdlib>  
24. #include <cctype>  
25. #include <string>  
26. #include <cstring>  
27. #include <cmath>  
28. #include <ctime>  
29. #define MAX 100000000  
30. #define LOCA  
31. #define PI acos(-1.0)  
32. using namespace std;  
33. bool tag[5000001];  
34. int p[4000001];  
35. int cnt;  
36. void get_prime() //筛出5000000内素数  
37. {  
38.     cnt = 0;  
39.     tag[1] = 1;  
40.     for (int i = 2; i < 5000000; i++)  
41.     {  
42.         if (!tag[i])  
43.         p[cnt++] = i;  
44.         for (int j = 0; j < cnt && p[j] * i < 5000000; j++)  
45.         {  
46.             tag[i*p[j]] = 1;  
47.             if (i % p[j] == 0)  
48.             break;  
49.         }  
50.     }  
51. }  
52. int main()  
53. {  
54. #ifdef LOCAL  
55.     freopen("ride.in","r",stdin);  
56.     freopen("ride.out","w",stdout);  
57. #endif  
58.     int t, n, i;  
59.     get_prime();  
60.     scanf("%d", &t);  
61.     while(t--)  
62.     {  
63.         int nt = 0;  
64.         scanf("%d", &n);  
65.         int ans = 1;  
66.         if(!tag[n]) ans = 9; // 如果是素数，结果就是9  
67.         else  
68.         {  
69.             for(i = 0; i < cnt && p[i] * p[i] <= n; i++)   
70.             {  
71.                 if(n % p[i] == 0)  
72.                 {  
73.                     int ct = 0;  
74.                     while(n % p[i] == 0)  
75.                     {  
76.                         n /= p[i];  
77.                         ct++;  
78.                     }  
79.                     ans = ans * (ct + 1) * (ct + 1) * (ct + 2) * (ct + 2) / 4;  
80.                 }  
81.             }  
82.             if(!tag[n])  
83.             ans = ans * 9;  
84.         }  
85.         printf("%d\n", ans);  
86.     }  
87.     return 0;  
88. }  

题外话：

说一下这个线性筛素数的问题

利用了每个合数必有一个最小素因子。

每个合数仅被它的最小素因子筛去正好一次。所以为线性时间。

代码中体现在：

if(i%pr[j]==0)break;

pr数组中的素数是递增的,当i能整除pr[j]，那么i*pr[j+1]这个合数肯定被pr[j]乘以某个数筛掉。

因为i中含有pr[j],pr[j]比pr[j+1]小。接下去的素数同理。所以不用筛下去了。

在满足i%pr[j]==0这个条件之前以及第一次满足改条件时,pr[j]必定是pr[j]*i的最小因子。