HDU4542(反素数+DFS+暴力打表)

 

HDU4542(反素数+DFS+暴力打表)

分类： 数论 2013-05-04 14:52  123人阅读  评论(0)  收藏  举报

题目：小明系列故事——未知剩余系

 

题意：给出一个数K，和两个操作，如果操作是0，就求出一个最小的正整数X，满足X的约数个数为K，如果操作是1，就求出一个最小的X，满足X的约数个数为X-K。

[cpp]  view plain copy

1. #include<cstdio>  
2. #include<cstring>  
3. #include<cmath>  
4. #include<algorithm>  
5. using namespace std;  
6.   
7. typedef long long LL;  
8.   
9. const int ns=49000,top=15;  
10. const LL INF=((LL)1<<62)+1;  
11.   
12. LL ans;  
13. int m,k,type,cnt;  
14. int ip[ns+10];  
15. int p[100]={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47};  
16.   
17. void prim()  
18. {  
19.     int i,j;  
20.     for(i=1;i<=ns;i++) ip[i]=i;           //初始化i最多有i个与其互质的数  
21.     for(i=1;i<=ns;i++)  
22.     {  
23.           for(j=i;j<=ns;j+=i) ip[j]--;    //i为j的因子，所以j与i不互质，第j个数的互质数减少1  
24.           if(!ip[ip[i]]) ip[ip[i]]=i;     //此时ip[i]存的是不大于i的数与i互质的个数k=ip[i],  
25.            //如果ip[k]=0,表示小于i的所有数中，没有刚好有k个互质数的数  
26.            //故将ip[k]=i，表示刚好有k个与i互质的数个数最小为i  
27.           ip[i]=0; //标记刚好有k个互质数的数没有(不大于i的数不可能存在某个数与其互质的数的个数等于i);  
28.     }  
29. }  
30.   
31. void dfs(int fm,LL t,int pos)  
32. {  
33.     if (fm==k&&ans>t) ans=t;  
34.     if (fm>=k||(pos>=top)) return ;  
35.     for (int i=1; i<=62; i++)  
36.     {  
37.         if (t>ans/p[pos]||fm*(i+1)>k) break;  
38.         t*=p[pos];  
39.         if (k%(fm*(i+1))==0)  
40.         dfs(fm*(i+1),t,pos+1);  
41.     }  
42. }  
43.   
44. int main()  
45. {  
46.     prim();  
47.     int T,cas=0;  
48.     scanf("%d",&T);  
49.     while (T--)  
50.     {  
51.         scanf("%d%d",&type,&k);  
52.         if (type)  
53.         {  
54.             ans=ip[k];  
55.         }  
56.         else  
57.         {  
58.             ans=INF;  
59.             dfs(1,1,0);  
60.         }  
61.         printf("Case %d: ",++cas);  
62.         if (ans==0) printf("Illegal\n");  
63.         else if (ans>=INF) printf("INF\n");  
64.         else printf("%I64d\n",ans);  
65.     }  
66.     return 0;  
67. } 
68. 
    
69.  

    HDU4392(反素数强大的模版)

    分类： 数论 2013-08-03 19:05  32人阅读  评论(0)  收藏  举报

    题目：Maximum Number Of Divisors

    
    

    [java]  view plain copy

    1. import java.io.BufferedInputStream;   
    2. import java.math.BigInteger;   
    3. import java.util.ArrayList;   
    4. import java.util.HashMap;   
    5. import java.util.LinkedList;   
    6. import java.util.List;   
    7. import java.util.Map;   
    8. import java.util.Queue;   
    9. import java.util.Scanner;   
    10.    
    11. class Node   
    12. {   
    13.     private static final int MAXP = 60;   
    14.    
    15.     public BigInteger K;   
    16.     public long F;   
    17.     public int N;   
    18.     public int[] A;   
    19.    
    20.     public Node()   
    21.     {   
    22.         K = BigInteger.ZERO;   
    23.         A = new int[MAXP];   
    24.     }   
    25. }   
    26.    
    27. public class Main  
    28. {   
    29.     private static final int MAXIP = 250;   
    30.     private static final int MAXP = 60;   
    31.    
    32.     private static BigInteger[] prime;   
    33.    
    34.     private static void init()   
    35.     {   
    36.         boolean[] isPrime = new boolean[MAXIP];   
    37.         for(int i=0;i<MAXIP;++i)   
    38.         {   
    39.             isPrime[i] = true;   
    40.         }   
    41.         isPrime[0] = isPrime[1] = false;   
    42.         for(int i=4;i<MAXIP;i+=2)   
    43.         {   
    44.             isPrime[i] = false;   
    45.         }   
    46.         for(int i=3;i<MAXIP;i+=2)   
    47.         {   
    48.             for(int j=3;i*j<MAXIP;j+=2)   
    49.             {   
    50.                 isPrime[i*j] = false;   
    51.             }   
    52.         }   
    53.         prime = new BigInteger[MAXP];   
    54.         for(int i=0, j=0;i<MAXIP;++i)   
    55.         {   
    56.             if(isPrime[i])   
    57.             {   
    58.                 prime[j++] = BigInteger.valueOf(i);   
    59.             }   
    60.         }   
    61.     }   
    62.    
    63.     public static void main(String args[])   
    64.     {   
    65.         init();   
    66.         List<BigInteger> P = new ArrayList<BigInteger>();   
    67.         BigInteger MP = BigInteger.ZERO;   
    68.         List<Node> ans = new ArrayList<Node>();   
    69.         Scanner cin = new Scanner(new BufferedInputStream(System.in));   
    70.         while(cin.hasNext())   
    71.         {   
    72.             BigInteger temp = cin.nextBigInteger();   
    73.             P.add(temp);   
    74.             if(temp.compareTo(MP) == 1)   
    75.             {   
    76.                 MP = temp;   
    77.             }   
    78.             ans.add(new Node());   
    79.         }   
    80.         Map<Long, BigInteger> map = new HashMap<Long, BigInteger>();   
    81.         Queue<Node> queue = new LinkedList<Node>();   
    82.         Node origin = new Node();   
    83.         origin.K = BigInteger.ONE;   
    84.         origin.F = 1;   
    85.         origin.N = 0;   
    86.         queue.add(origin);   
    87.         map.put(origin.F, origin.K);   
    88.         while(!queue.isEmpty())   
    89.         {   
    90.             Node u = queue.peek();   
    91.             queue.remove();   
    92.             BigInteger compare = map.get(u.F);   
    93.             if(compare != null)   
    94.             {   
    95.                 if(compare.compareTo(u.K) == -1)   
    96.                 {   
    97.                     continue;   
    98.                 }   
    99.             }   
    100.             for(int i=0;i<P.size();++i)   
    101.             {   
    102.                 if(u.K.compareTo(P.get(i)) <= 0)   
    103.                 {   
    104.                     if(u.F > ans.get(i).F)   
    105.                     {   
    106.                         ans.get(i).F = u.F;   
    107.                         ans.get(i).K = u.K;   
    108.                     }   
    109.                     else if(u.F == ans.get(i).F)   
    110.                     {   
    111.                         if(u.K.compareTo(ans.get(i).K) == -1)   
    112.                         {   
    113.                             ans.get(i).K = u.K;   
    114.                         }   
    115.                     }   
    116.                 }   
    117.             }   
    118.             for(int i=0;i<u.N;++i)   
    119.             {   
    120.                 Node v = new Node();   
    121.                 v.K = u.K.multiply(prime[i]);   
    122.                 if(v.K.compareTo(MP) <= 0)   
    123.                 {   
    124.                     v.F = u.F / (u.A[i] + 1) * (u.A[i] + 2);   
    125.                     v.N = u.N;   
    126.                     for(int j=0;j<u.N;++j)   
    127.                     {   
    128.                         v.A[j] = u.A[j];   
    129.                     }   
    130.                     ++ v.A[i];   
    131.                     boolean flag = true;   
    132.                     compare = map.get(v.F);   
    133.                     if(compare != null)   
    134.                     {   
    135.                         if(compare.compareTo(v.K) <= 0)   
    136.                         {   
    137.                             flag = false;   
    138.                         }   
    139.                         else   
    140.                         {   
    141.                             map.remove(v.F);   
    142.                         }   
    143.                     }   
    144.                     if(flag)   
    145.                     {   
    146.                         queue.add(v);   
    147.                         map.put(v.F, v.K);   
    148.                     }   
    149.                 }   
    150.             }   
    151.             Node v = new Node();   
    152.             v.K = u.K.multiply(prime[u.N]);   
    153.             if(v.K.compareTo(MP) <= 0)   
    154.             {   
    155.                 v.F = u.F * 2;   
    156.                 v.N = u.N + 1;   
    157.                 for(int i=0;i<u.N;++i)   
    158.                 {   
    159.                     v.A[i] = u.A[i];   
    160.                 }   
    161.                 ++ v.A[u.N];   
    162.                 boolean flag = true;   
    163.                 compare = map.get(v.F);   
    164.                 if(compare != null)   
    165.                 {   
    166.                     if(compare.compareTo(v.K) <= 0)   
    167.                     {   
    168.                         flag = false;   
    169.                     }   
    170.                     else   
    171.                     {   
    172.                         map.remove(v.F);   
    173.                     }   
    174.                 }   
    175.                 if(flag)   
    176.                 {   
    177.                     queue.add(v);   
    178.                     map.put(v.F, v.K);   
    179.                 }   
    180.             }   
    181.         }   
    182.         for(int i=0;i<ans.size();++i)   
    183.         {   
    184.             System.out.println(ans.get(i).K.toString() + " " + ans.get(i).F); //第一个数为满足因子个数最多的K，第二个数为K的因子个数  
    185.         }   
    186.     }   
    187. }