USACOTrainning.Section 3.1.Humble Numbers

最新推荐文章于 2025-09-10 15:16:07 发布

weixin_30675967

最新推荐文章于 2025-09-10 15:16:07 发布

阅读量59

点赞数

CC 4.0 BY-SA版权

文章标签： c/c++

原文链接：http://www.cnblogs.com/litstrong/archive/2011/03/03/1970253.html

本文介绍了Humble Numbers问题的两种解决方法。一种是使用最小堆维护当前最小丑数，复杂度较高；另一种是通过记录乘积位置优化算法，将复杂度降至O(K+N)。

上道Score Inflation已经是去年10月的事情了，之前卡在了Humble Numbers这道题了，其实这道在很早之前就做过了，在POJ上，不过给忘了，也不知道怎么做了。先说下题意，给定K个素数，求出第N个丑数，丑数的定义是，若干个数的乘积，而这些数都来自于之前给定的K个素数的集合。

想了个很暴力的方法，用一个最小堆来维护当前的最小的丑数，然后POP出去，用这个数和那K个素数相乘，判定是否唯一，然后放进最小堆，早就知道不行，还很弱的去写了一下，用STL实现，更加超时了，复杂度是O(K*N)。

参考了这，这，官方的做法是用一个表，有序放丑数，假设有m个，第m+1个丑数，用素数集合中的数去和m个丑数相乘，第一个和某数相乘的丑数大于第m个丑数的话，它就有可能是第m+1个丑数，这些可能的值，取个最小的就是第m+1个丑数了，这样还不行，复杂度其实还是O(K*N)，可以用二分的方法来加速，但也没把复杂度降下来。于是这个优化就很强大了，用一个数组记录乘积大于第m个丑数的位置，下次不从头开始枚举，而是从该位置开始枚举，就可以把复杂度降到O(K+N)了。

相比这些，我的那个暴力的方法每次不仅仅把第N个的算出来了，还把很多没用的数也算了出来，代码如下：

 
   /* 
   ID: litstrong 
   PROG: humble 
   LANG: C++ 
   */ 
   #include <iostream> 
   #include <string> 
   #include <vector> 
   #include <set> 
   #include <math.h> 
   #include <queue> 
   #include <algorithm> 
   #include <string.h> 
   #include <stdio.h> 
   using namespace std; 
     
   const int MAX = 105; 
   const int MAXN = 100005; 
     
   int num[MAX], m_index[MAX]; 
   int prime[MAXN]; 
     
   int K, N; 
     
   class CNUM 
   { 
   public: 
       int m_val; 
       CNUM() {} 
       CNUM(int m) : m_val(m) {} 
       bool operator < (const CNUM &t) const 
       { 
           return m_val > t.m_val; 
       } 
   }; 
     
   int go() 
   { 
       priority_queue<CNUM> Q; 
       set<int> one; 
       sort(num, num + K); 
       Q.push(1); 
       for(int i = 0; i <= N; i++) 
       { 
           int m_min = Q.top().m_val; 
           //printf("%d %d\n", i, m_min); 
           if(i == N)  return m_min; 
           Q.pop(); 
           for(int j = 0; j < K; j++) 
           { 
               int m_num = m_min * num[j]; 
               if(one.find(m_num) == one.end()) 
               { 
                   one.insert(m_num); 
                   Q.push(CNUM(m_num)); 
               } 
           } 
       } 
       return 0; 
   } 
     
   int go_ans() 
   { 
       sort(num, num + K); 
       memset(m_index, 0, sizeof(m_index)); 
       int top_num = 0; 
       prime[top_num++] = 1; 
       while(top_num <= N) 
       { 
           int m_min = -1; 
           for(int i = 0; i < K; i++) 
           { 
               while(num[i] * prime[m_index[i]] <= prime[top_num - 1] && m_index[i] < top_num) 
                   m_index[i]++; 
               if(m_index[i] < top_num)   
               { 
                   if(m_min == -1 || num[i] * prime[m_index[i]] < m_min) 
                       m_min = num[i] * prime[m_index[i]]; 
               } 
           } 
           prime[top_num++] = m_min; 
       } 
       return prime[N]; 
   } 
     
   int main() 
   { 
       //freopen("humble.in", "r", stdin); 
       //freopen("humble.out", "w", stdout); 
     
       int k, n; 
       scanf("%d%d", &K, &N); 
       for(int i = 0; i < K; i++) 
           scanf("%d", &num[i]); 
       printf("%d\n", go_ans()); 
   } 
  