丑数 和 超级丑数

给你一个整数 n ，请你找出并返回第 n 个 丑数 。丑数 就是只包含质因数 2、3 和 5 的正整数。

示例 1：
输入：n = 10
输出：12
解释：[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。

示例 2：
输入：n = 1
输出：1
解释：1 通常被视为丑数

package com.loo;

import java.util.Arrays;
import java.util.Queue;
import java.util.TreeSet;
import java.util.PriorityQueue;
import java.util.Comparator;

public class SupperUglyNumber {

    public static void main(String[] args) {
        int[] arr = new int[] { 2 , 7 , 13 , 19 };
        int n = 10;
        System.out.println(getSupperUglyNumber1(n));
        System.out.println(getSupperUglyNumber2(n));
        System.out.println(getSupperUglyNumber3(n));
        System.out.println(getSupperUglyNumber4(arr , n));
        System.out.println(getSupperUglyNumber5(arr , n));
    }

    public static int getSupperUglyNumber1(int n) {
        int[] dp = new int[n+1];
        int p2 = 1, p3 = 1 , p5 = 1;
        dp[1] = 1;
        for (int i=2;i<=n;i++) {
            int num2 = dp[p2] * 2;
            int num3 = dp[p3] * 3;
            int num5 = dp[p5] * 5;
            dp[i] = Math.min(Math.min(num2 , num3) , num5);
            if (dp[i] == num2) {
                p2++;
            }
            if (dp[i] == num3) {
                p3++;
            }
            if (dp[i] == num5) {
                p5++;
            }
        }
        return dp[n];
    }

    public static int getSupperUglyNumber2(int n) {
        Queue<Long> queue = new PriorityQueue<Long>();
        int count = 0;
        long result = 1;
        queue.add(result);
        while (count < n) {
            result = queue.poll();
            while (!queue.isEmpty() && result == queue.peek()) {
                queue.poll();
            }
            queue.offer(result * 2);
            queue.offer(result * 3);
            queue.offer(result * 5);
            count++;
        }
        return (int)result;
    }

    public static int getSupperUglyNumber3(int n) {
        TreeSet<Long> set = new TreeSet<Long>();
        int count = 0;
        long result = 1;
        set.add(result);
        while (count < n) {
            result = set.pollFirst();
            count++;
            set.add(result * 2);
            set.add(result * 3);
            set.add(result * 5);
        }
        return (int) result;
    }

对上面做一个变形：
超级丑数 是一个正整数，并满足其所有质因数都出现在质数数组 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] 中。

    public static int getSupperUglyNumber4(int[] primes , int n) {
        if (primes == null || primes.length == 0 || n < 0) {
            return 0;
        }
        int m = primes.length;
        int[] dp = new int[n + 1];
        int[] pointers = new int[m];
        int[] nums = new int[m];
        Arrays.fill(nums , 1);
        for (int i=1;i<=n;i++) {
            int minNum = Arrays.stream(nums).min().getAsInt();
            dp[i] = minNum;
            for (int j=0;j<m;j++) {
                if (nums[j] == minNum) {
                    pointers[j]++;
                    nums[j] = dp[pointers[j]] * primes[j];
                }
            }
        }
        return dp[n];
    }

    public static int getSupperUglyNumber5(int[] primes , int n) {
        TreeSet<Long> set = new TreeSet<Long>();
        int count = 0;
        long result = 1;
        set.add(result);
        while (count < n) {
            result = set.pollFirst();
            count++;
            /*set.add(result * 2);
            set.add(result * 7);
            set.add(result * 13);
            set.add(result * 19);*/
            for (int i=0;i<arr.length;i++) {
                set.add(result * primes[i]);
            }
        }
        return (int) result;
    }
                                                                                                                                                                                                            
}