leetcode：313. 超级丑数

题目来源

• leetcode：313. 超级丑数

题目描述

题目解析

超级丑数中的[超级]是相对于leetcode：264. 丑数 II来说的。之前丑数是质因数只能为{2，3，5}，而本题质因子来自某个长度不确定的整数列表，所以叫做【超级】

举个例子对于例子一，说白了其实就是把计算丑数数列那个2，3，5换成2，7，13，19罢了

根据丑数的定义，我们有如下结论：

• 1 是最小的丑数。
• 对于任意一个丑数 x，其与任意给定的质因数 primes[i]相乘，结果仍为丑数。

要求返回第n个超级丑数，是指第n小的超级丑数。

动态规划

思路

• 第n个超级丑数是基于前面某一个超级丑数乘以primes[i] 得到的，基于这一点（递推关系），可以使用「动态规划」。

算法

状态定义： dp[i]表示第i+1个超级丑数，第1个超级丑数是dp[0]，第 2 个超级丑数是 dp[1]，……

以「示例 1」为例，primes = [2, 7, 13, 19]。

• 第一个超级丑数是$2^0、7^0、13^0、19^0$，因此dp[0] = 1
• 第二个超级丑数是基于第一个超级丑数dp[0]「乘以 2」或者「乘以 7」或者「乘以 13」或者「乘以 19」得到，选出最小者为 dp[0] 「乘以 2」，即 $dp[1]=dp[0]\ast 2=2$。那么
  • 下一个丑数如果是因为「乘以 2」得到，一定不是基于 dp[0] 而是基于 dp[1]，这一点很重要。
• 第 3 个超级丑数，比较这四个数：$dp[1]\ast 2=4，dp[0]\ast 7=7、dp[0]\ast 13=13、dp[0]\ast 19=19$，选出最小的是 dp[2] = dp[1] * 2 = 4，那么下一个丑数如果是因为「乘以 2」得到，一定是基于 dp[2]。

以此类推选下去，直到选出第 n 个丑数 $dp[n-1]$。基于哪一个超级丑数，可以使用一个长度和 $primes$ 相等的数组 $indexes$ 记录下来，indexes[i] 表示下一个丑数如果选择了 primes[i] 是基于哪一个下标的超级丑数得到的。

选超级丑数的过程就相当于有primes.length这么多指针，在超级丑数列表上前进，一开始都在下标 0，然后 每一次可能选出多干个指针，让它们各前进一步，不回头。

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        int pLen = primes.size();
        // 由于我们不知道质数的个数，我们可以用一个idx数组来保存当前的位置
        std::vector<int> indexes (pLen, 0);
        std::vector<int> dp(pLen);
        dp[0] = 1;
        for (int i = 1; i < n; ++i) {
            // 因为选最小值，先假设一个最大值
            vector<int> tmp;
            int mn = INT32_MAX;
            for (int h = 0; h < primes.size(); ++h) {
                tmp.push_back(dp[indexes[i]] * primes[i]);
            }
            
            // 从每个子链中取出一个数，找出其中最小值
            for (int j = 0; j < primes.size(); ++j) {
                mn = std::min(mn, tmp[i]);
            }

            //更新idx数组对应位置，注意有可能最小值不止一个，要更新所有最小值的位置
            for (int k = 0; k < primes.size(); ++k) {
                if(mn == tmp[i]){
                    ++indexes[k];
                }
            }
            dp[i] = mn;
        }
        return dp.back();
    }
};

上述代码可以稍稍改写一下，变得更简洁一些，原理完全相同

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        // 由于我们不知道质数的个数，我们可以用一个idx数组来保存当前的位置
        std::vector<int> idx (primes.size(), 0);
        std::vector<int> dp(n, 1);
        dp[0] = 1;


        for (int i = 1; i < n; ++i) {
            // 因为选最小值，先假设一个最大值
            dp[i] = INT32_MAX;
            for (int j = 0; j < primes.size(); ++j) {
                dp[i] = min(dp[i], dp[idx[j]] * primes[j]);
            }
            // dp[i] 是之前的哪个丑数乘以对应的 primes[j] 选出来的，给它加 1
            for (int j = 0; j < primes.size(); ++j) {
                if (dp[i] == dp[idx[j]] * primes[j]) {
                    ++idx[j];
                }
            }
        }
        return dp.back();
    }
};

小根堆（超时）

有了基本的分析思路，一个简单的解法是使用优先队列：

• 起始先将最小丑数放入队列
• 每次从队列中取出最小值x，然后将x所对应的丑数x * primes[i]入队
• 对2循环多次，第n次出队就是答案

丑数的生成过程可以想象成一棵树的产生过程

• 假设 primes = [2,7,13,19]，每一层产生的数字都去乘以 primes 中的每个元素
• 这个题目想要我们给出的答案是整个丑数生成的过程中，第 n 个小的丑数

本质：实现一个支持排序和去重的队列

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        std::set<long long> s;
        s.insert(1LL);
        while (--n){
            long long ugly = *s.begin();
            s.erase(s.begin());
            for(auto p : primes){
                s.insert(ugly * p);
            }
        }
        return *s.begin();
    }
};

类似题目

题目	思路
leetcode：21. 合并两个有序链表 Merge Two Sorted Lists
leetcode：23. 合并K个升序链表Merge K Sorted Lists
leetcode：263. n是不是丑数 Ugly Number	分别不停的除以 2，3，5，并且看最后剩下来的数字是否为1
leetcode：264. 返回第n个丑数 I Ugly Number II	最小堆
leetcode：313. 超级丑数 Super Ugly Number	只能动态规划，否则会超时
leetcode：202. 快乐数 Happy Number	检测环
leetcode：204. 计数质数 count-primes
leetcode：279.完全平方数 perfect-squares