Leetcode 313: Super Ugly Number (超级丑数)

纸上得来终觉浅绝知此事要躬行2023-10-14 10:13

Super Ugly Number
Medium
A super ugly number is a positive integer whose prime factors are in the array primes.
Given an integer n and an array of integers primes, return the nth super ugly number.
The nth super ugly number is guaranteed to fit in a 32-bit signed integer.

Example 1:

Input: n = 12, primes = $2,7,13,19$

Output: 32

Explanation: $1,2,4,7,8,13,14,16,19,26,28,32$ is the sequence of the first 12 super ugly numbers given primes = $2,7,13,19$ .

Example 2:

Input: n = 1, primes = $2,3,5$

Output: 1

Explanation: 1 has no prime factors, therefore all of its prime factors are in the array primes = $2,3,5$ .

Constraints:

1 <= n <= 105

1 <= primes.length <= 100

2 <= primes $i$ <= 1000

primes $i$ is guaranteed to be a prime number.

All the values of primes are unique and sorted in ascending order.

解法1：用Heap做。注意去重可以用topNode.product != uglys $index$ 。

cpp 复制代码

struct Node {
    int prime;
    int index;
    long long product;
    Node(int pri, int id, long long pro) : prime(pri), index(id), product(pro) {}
    bool operator < (const Node & node) const {
        return product >= node.product;
    }
};

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        int primesCount = primes.size();
        vector<long long> uglys(n + 1, 0);
        vector<int> indexes(primesCount, 1);
        priority_queue<Node> minHeap;
        uglys[1] = 1;
        int index = 1;
        for (int i = 0; i < primesCount; i++) {
            minHeap.push(Node(primes[i], 1, primes[i])); //1 * primes[i] = primes[i]
        }

        while (index <= n) {
            int minV = INT_MAX;
            Node topNode = minHeap.top();
            minHeap.pop();
            if (topNode.product != uglys[index]) {
                if (index < n) {
                    uglys[++index] = topNode.product;
                }
                else break;
            }
            minHeap.push(Node(topNode.prime, topNode.index + 1, uglys[topNode.index + 1] * topNode.prime));
        }
        return (int)uglys[n];
    }
};