【Leetcode】313. Super Ugly Number

题目地址：

https://leetcode.com/problems/super-ugly-number/

给定若干素数组成的数组$A$，一个数是丑数，当且仅当其素因子只包含$A$里的那些。问第$n$个丑数是几。规定$1$是第$1$个丑数。

思路可以参考https://blog.csdn.net/qq_46105170/article/details/108841467。由于这里需要实现快速查找最小值，所以可以用最小堆来做。并且，可以将值、指针对应的素数和指针指向的下标打包成一个class，以便知道怎样移动指针。代码如下：

import java.util.PriorityQueue;

public class Solution {
    
    class Tuple {
    	// val存丑数，prime存其对应的素数，idx存指针指向的下标
        int val, prime, idx;
        
        public Tuple(int val, int prime, int idx) {
            this.val = val;
            this.prime = prime;
            this.idx = idx;
        }
    }
    
    public int nthSuperUglyNumber(int n, int[] primes) {
    	// 特判n = 1
        if (n == 1) {
            return 1;
        }
        
        int[] nums = new int[n];
        nums[0] = 1;
        int size = 1;
        PriorityQueue<Tuple> minHeap = new PriorityQueue<>((p1, p2) -> Integer.compare(p1.val, p2.val));
        
        // 三个指针都指向下标1
        for (int prime : primes) {
            minHeap.offer(new Tuple(prime, prime, 1));
        }
        
        // 可以只求第n - 1个丑数，然后堆顶就是第n个丑数。但这样的话前面一定要特判n = 1的情况
        while (size < n - 1) {
            Tuple cur = minHeap.poll();
            // 得到第size + 1个丑数
            nums[size++] = cur.val;
            minHeap.offer(new Tuple(nums[cur.idx] * cur.prime, cur.prime, cur.idx + 1));
            // 相同数不要重复加
            while (!minHeap.isEmpty() && minHeap.peek().val == nums[size - 1]) {
                cur = minHeap.poll();
                minHeap.offer(new Tuple(nums[cur.idx] * cur.prime, cur.prime, cur.idx + 1));
            }
        }
        
        return minHeap.peek().val;
    }
}

时间复杂度$O(n\log k)$，空间$O(k)$，$k$为素数个数。