反素数深度分析

转载自：http://blog.csdn.net/ACdreamers/article/details/25049767

今天要我要讲的是反素数，在ACM中也算是常见的考点，那么对于搞ACM的同学来说，很有必要搞清楚它，所以接下

来我会很详细地讲解。

 

在讲解反素数之前，我们先来看反素数的概念。

 

反素数的定义：对于任何正整数，其约数个数记为，例如，如果某个正整数满足：对任意的正整

            数，都有，那么称为反素数。

 

从反素数的定义中可以看出两个性质：

 

（1）一个反素数的所有质因子必然是从2开始的连续若干个质数，因为反素数是保证约数个数为的这个数尽量小

（2）同样的道理，如果，那么必有

 

 

在ACM竞赛中，最常见的问题如下：

 

（1）给定一个数，求一个最小的正整数，使得的约数个数为

（2）求出中约数个数最多的这个数

 

从上面的性质中可以看出，我们要求最小的，它的约数个数为，那么可以利用搜索来解。

 

以前我们求一个数的所有因子也是用搜索，比如，以每一个为树的一层建立搜索树，深度为

以为例进行说明，建树如下：

 

 

可以看出从根节点到每一个叶子结点这条路径上的所有数字乘起来都是12的约数，所以12有6个约数。

 

搜索的思路就明显了，从根节点开始进行深搜，到叶子结点，代码如下：

[cpp] view plaincopy

1. void dfs(int dept,LL ans = 1)  
2. {  
3.     if(dept == cnt)  
4.     {  
5.         fac[ct++] = ans;  
6.         return;  
7.     }  
8.     for(int i=0;i<=num[dept];i++)  
9.     {  
10.         dfs(dept+1,ans);  
11.         ans *= pri[dept];  
12.     }  
13. }  

回到我们的问题，同样用搜索来求最小的。

 

题目：http://codeforces.com/problemset/problem/27/E

 

题意：给一个数，求一个最小的正整数，使得它的因子个数为。

 

分析：与求因子的方法类似，先建立搜索树，以每一个为一层建立树型结构，进行搜索，取最小的。

 

[cpp] view plaincopy

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6. typedef unsigned long long ULL;  
7. const ULL INF = ~0ULL;  
8.   
9. int p[16] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53};  
10.   
11. int n;  
12. ULL ans;  
13.   
14. void dfs(int dept,ULL tmp,int num)  
15. {  
16.     if(num > n) return;  
17.     if(num == n && ans > tmp) ans = tmp;  
18.     for(int i=1;i<=63;i++)  
19.     {  
20.         if(ans / p[dept] < tmp) break;  
21.         dfs(dept+1,tmp *= p[dept],num*(i+1));  
22.     }  
23. }  
24.   
25. int main()  
26. {  
27.     while(cin>>n)  
28.     {  
29.         ans = INF;  
30.         dfs(0,1,1);  
31.         cout<<ans<<endl;  
32.     }  
33.     return 0;  
34. }  

 

题目：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=1562

 

题意：求以内的因子最多的那个数。

分析：基本上跟上题差不多。

 

代码：

[cpp] view plaincopy

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6. typedef unsigned long long ULL;  
7. const ULL INF = ~0ULL;  
8.   
9. int p[16] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53};  
10.   
11. ULL ans,n;  
12. int best;  
13.   
14. void dfs(int dept,ULL tmp,int num)  
15. {  
16.     //到叶子结点，返回  
17.     if(dept >= 16) return;  
18.     //num记录的因子个数，如果遇到更小的，就更新  
19.     if(num > best)  
20.     {  
21.         best = num;  
22.         ans = tmp;  
23.     }  
24.     //当因子个数相同时，取值最小的  
25.     if(num == best && ans > tmp) ans = tmp;  
26.     for(int i=1;i<=63;i++)  
27.     {  
28.         if(n / p[dept] < tmp) break;  
29.         dfs(dept+1,tmp *= p[dept],num*(i+1));  
30.     }  
31. }  
32.   
33. int main()  
34. {  
35.     while(cin>>n)  
36.     {  
37.         ans = INF;  
38.         best = 0;  
39.         dfs(0,1,1);  
40.         cout<<ans<<endl;  
41.     }  
42.     return 0;  
43. }  

 

题目：http://acm.timus.ru/problem.aspx?space=1&num=1748

 

分析：这道题主要注意数据处理。对于上面的两题，数据范围小，所以可以不用剪枝，本题就需要了。

[cpp] view plaincopy

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6. typedef unsigned long long ULL;  
7. const ULL INF = ~0ULL;  
8.   
9. int p[16] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53};  
10.   
11. ULL ans,n;  
12. int best;  
13.   
14. void dfs(int dept,int limit,ULL tmp,int num)  
15. {  
16.     if(tmp > n) return;  
17.     if(num > best)  
18.     {  
19.         best = num;  
20.         ans = tmp;  
21.     }  
22.     if(num == best && ans > tmp) ans = tmp;  
23.     for(int i=1;i<=limit;i++)  
24.     {  
25.         double cur = (double)tmp;  
26.         if(n < cur*p[dept]) break;  
27.         dfs(dept+1,i,tmp *= p[dept],num*(i+1));  
28.     }  
29. }  
30.   
31. int main()  
32. {  
33.     int T;  
34.     cin>>T;  
35.     while(T--)  
36.     {  
37.         cin>>n;  
38.         ans = INF;  
39.         best = 0;  
40.         dfs(0,60,1,1);  
41.         cout<<ans<<" "<<best<<endl;  
42.     }  
43.     return 0;  
44. }  

 

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

 

题意：

   给出一个数K和两个操作

    如果操作是0，就求出一个最小的正整数X，满足X的约数个数为K。

    如果操作是1，就求出一个最小的X，满足X的约数个数为X-K。

 

分析：对于操作0，就是求反素数，直接搜索搞定。对于操作1，代表1至X中不是X的约数个数为K。

 

代码：

[cpp] view plaincopy

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6. const int N = 50005;  
7. typedef long long LL;  
8. const LL INF = (((LL)1)<<62)+1;  
9.   
10. int p[16] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53};  
11.   
12. LL ans;  
13. int n;  
14. int d[N];  
15.   
16. void Init()  
17. {  
18.     for(int i=1;i<N;i++) d[i] = i;  
19.     for(int i=1;i<N;i++)  
20.     {  
21.         for(int j=i;j<N;j+=i) d[j]--;  
22.         if(!d[d[i]]) d[d[i]] = i;  
23.         d[i] = 0;  
24.     }  
25. }  
26.   
27. void dfs(int dept,int limit,LL tmp,int num)  
28. {  
29.     if(num > n) return;  
30.     if(num == n && ans > tmp) ans = tmp;  
31.     for(int i=1;i<=limit;i++)  
32.     {  
33.         if(ans / p[dept] < tmp || num*(i+1) > n) break;  
34.         tmp *= p[dept];  
35.         if(n % (num*(i+1)) == 0)  
36.             dfs(dept+1,i,tmp,num*(i+1));  
37.     }  
38. }  
39.   
40. int main()  
41. {  
42.     Init();  
43.     int T,tt=1;  
44.     scanf("%d",&T);  
45.     while(T--)  
46.     {  
47.         int type;  
48.         scanf("%d%d",&type,&n);  
49.         if(type) ans = d[n];  
50.         else  
51.         {  
52.             ans = INF;  
53.             dfs(0,62,1,1);  
54.         }  
55.         printf("Case %d: ",tt++);  
56.         if(ans == 0) puts("Illegal");  
57.         else if(ans >= INF) puts("INF");  
58.         else printf("%I64d\n",ans);  
59.     }  
60.     return 0;  
61. }