313. 超级丑数

 

难度中等324收藏分享切换为英文接收动态反馈

超级丑数 是一个正整数，并满足其所有质因数都出现在质数数组 primes 中。

给你一个整数 n 和一个整数数组 primes ，返回第 n 个 超级丑数 。

题目数据保证第 n 个 超级丑数 在 32-bit 带符号整数范围内。

 

示例 1：

输入：n = 12, primes = [2,7,13,19]
输出：32 
解释：给定长度为 4 的质数数组 primes = [2,7,13,19]，前 12 个超级丑数序列为：[1,2,4,7,8,13,14,16,19,26,28,32] 。

示例 2：

输入：n = 1, primes = [2,3,5]
输出：1
解释：1 不含质因数，因此它的所有质因数都在质数数组 primes = [2,3,5] 中。

 

 

 

class Solution:
    def nthSuperUglyNumber(self, n: int, primes: List[int]) -> int:

        res = [1]
        p_index = [0] * len(primes)
        while len(res) < n:
            mina = min([res[p_index[i]]*primes[i] for i in range(len(primes))])
            for i in range(len(primes)):
                if mina == res[p_index[i]]*primes[i]:
                    p_index[i]+=1
            res.append(mina)
        print(res)
        return res[-1]

 

 

 

 

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        priority_queue<double,vector<double>,greater<double>> q;
        unordered_set<double> set;
        q.push(1.0);
        set.insert(1.0);
        double res = 1;
        for(int i = 1; i <= n;i++) {            
            double top = q.top();
            res = top;
            q.pop();
            for (auto p : primes) {
                double cur_val = double(p)*res;
                if (set.find(cur_val)==set.end()) {
                    q.push(cur_val);
                    set.insert(cur_val);
                }
            }
        } 
        return res;
    }
};

 

 

 

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        vector<int> p_index = vector<int>(primes.size(),0);
        vector<double> dp = vector<double>(n,1);
        for(int i = 1; i < n ;i++) {
            double cur_min = primes[0]*dp[p_index[0]];
            for(int j = 1; j < primes.size();j++) {
                if (cur_min > primes[j]*dp[p_index[j]]) {
                    cur_min = primes[j]*dp[p_index[j]];
                }
            }
            for(int j = 0; j < primes.size();j++) {
                if (cur_min == primes[j]*dp[p_index[j]]) {
                    p_index[j]++;
                }
            }
            dp[i] = cur_min;
        }
        return dp[n-1];
    }
};