leetcode 313 超级丑数 动态规划 最小堆

如果用动态规划
设dp[i]为第i个超级丑数，则可以很自然的想到dp[i]可以由dp[0]到dp[i-1]每个乘以primes的数组中的每个素数，在primes数组和dp 0到i-1上取最小得到，但是这样的时间复杂度为O(nmn) 因为里面有很多是重复的比较
想这样的一个过程素数2 3 5 7
第一个超级丑数是1，则接下来比较12 13 15 17
得到是最小是2 所以第二个超级丑数是2
接下来比较22 31 51 71 为什么，因为21显然不用比较，因为21不必第二个超级丑数大，也比22小，32自然也不用比较，因为31比32来的小，同时由上次的比较结果31肯定比第二个超级丑数2来的大，同理51 71也是这样。
所以我们可以存放大小为m的数组ptrs，每个与primes数组对应，ptrs[j]指向当前所乘的dp数在dp数组中的下标，使得dp[ptrs[j]]*primes[j]始终是最小的，我们可以称这些数为“当前最小的丑数”我们需要的最小的，就从这些数中选j从0到m-1
需要注意的是，“当前最小的丑数”当中最小值可能有多个，当我们选出一个最小值时，需要把其他和这个最小值相等的那些数的ptrs值加1，不然这些数就会是下一轮比较中最小的，就会出现多个数，比如2个14这样子

int nthSuperUglyNumber(int n, int* primes, int primesSize){
     int dp[n];
     dp[0]=1;
     int ptrs[primesSize];
     for(int i=0;i<primesSize;i++)
     {
         ptrs[i]=0;
     }
     for(int i=1;i<n;i++)
     {
         int minn=0x7fffffff;
         for(int j=0;j<primesSize;j++)
         {
            if(dp[ptrs[j]]*primes[j]<minn)
            {
                minn=dp[ptrs[j]]*primes[j];
            }
         }
         dp[i]=minn;
         for(int j=0;j<primesSize;j++)
         {
             if(dp[i]==dp[ptrs[j]]*primes[j])
             ptrs[j]++;
         }
     }
     return dp[n-1];
}

最小堆
原理基本同上相同，只是最小堆每次更多的“当前最小丑数”给放进堆里了
要得到从小到大的第 nn 个超级丑数，可以使用最小堆实现。

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        unordered_set<long> seen;
        priority_queue<long, vector<long>, greater<long>> heap;
        seen.insert(1);
        heap.push(1);
        int ans = 0;
        for (int i = 0; i < n; i++) {
            long curr = heap.top();
            heap.pop();
            ans = (int)curr;
            for (int prime : primes) {
                long next = curr * prime;
                if (seen.insert(next).second) {
                    heap.push(next);
                }
            }
        }
        return ans;
    }
};

首先 一共有n次循环，而堆的操作都可以在logn内完成，n为堆里元素的数目，每次循环都要执行取最小的，log(nm)(最多为nm)，然后循环prime里的内容 m次，每次最坏情况下把一个数加入堆中 即mlognm,所以每次循环时间复杂度为O(lognm+mlognm) =O(mlognm) 一共有n次循环，所以总的时间复杂度为nmlognm
最小堆和哈希集合的空间都不会超过nm,所以空间复杂度为O(nm)