Ugly number丑数2，超级丑数

［抄题］：

［思维问题］：

［一句话思路］：Long.valueOf(2)转换为long型再做

［输入量］：空： 正常情况：特大：特小：程序里处理到的特殊情况：异常情况（不合法不合理的输入）：

［画图］：

［一刷］：

1. 取出数从i = 1开始，不用从0开始。因为第一个符合条件的数是1 。先定义number 是long1，之后再换。

［二刷］：

1. primes[0] = Long.valueOf(2);这样大写 Long[]表示长数组的类型
2. queue用poll 
3. 最后返回intValue

［三刷］：

［四刷］：

［五刷］：

［总结］：

［复杂度］：Time complexity: O(nlogn) 两个都遍历时做乘法 Space complexity: O(n)（都是n）

［英文数据结构，为什么不用别的数据结构］：

随意插入：pq heap，防止重复插入：hashset

queue是接口类，可以实例化为pq

［其他解法］：

［Follow Up］：

［题目变变变］：

public class Solution {
    /*
     * @param n: An integer
     * @return: the nth prime number as description.
     */
    public int nthUglyNumber(int n) {
        Queue<Long> Q = new PriorityQueue<Long>();
        HashSet<Long> inQ = new HashSet<Long>();
        Long[] primes = new Long[3];
        
        primes[0] = Long.valueOf(2);
        primes[1] = Long.valueOf(3);
        primes[2] = Long.valueOf(5);
        for (int i = 0; i < 3; i++) {
            Q.add(primes[i]);
            inQ.add(primes[i]);
        }
        Long number = Long.valueOf(1);
        for (int i = 1; i < n; i++) {
            number = Q.poll();
            for (int j = 0; j < 3; j++) {
                if (!inQ.contains(primes[j] * number)) {
                    Q.add(primes[j] * number);
                    inQ.add(primes[j] * number);
                }
            }
        }
        return number.intValue();
    }
}

超级丑数 

［抄题］：

写一个程序来找第 n 个超级丑数。

超级丑数的定义是正整数并且所有的质数因子都在所给定的一个大小为 k 的质数集合内。

比如给你 4 个质数的集合 [2, 7, 13, 19], 那么 [1, 2, 4, 7, 8, 13, 14, 16, 19, 26, 28, 32] 是前 12 个超级丑数。

［思维问题］：

没发现是新定义的质数，比如4，8

［一句话思路］：

引入times[]数组，用ugly[times]来表示最大的丑数

［输入量］：空： 正常情况：特大：特小：程序里处理到的特殊情况：异常情况（不合法不合理的输入）：

［画图］：

［一刷］：

times［j］的统计是在每一个统计丑数i之内，都要做的

［二刷］：

［三刷］：

［四刷］：

［五刷］：

［总结］：

［复杂度］：Time complexity: O(n^2) Space complexity: O(n)

［英文数据结构，为什么不用别的数据结构］：

不需要判断是否重复，不用hashset。

需要逐渐往上做乘法，遍历，用array合适。

［其他解法］：

［Follow Up］：

［题目变变变］：

public class Solution {
    /*
     * @param n: a positive integer
     * @param primes: the given prime list
     * @return: the nth super ugly number
     */
    public int nthSuperUglyNumber(int n, int[] primes) {
        if (primes == null || n <= 0) {
            return 0;
        }
        //find min
        int[]ugly = new int[n];
        int[]times = new int[primes.length];
        ugly[0] = 1;
        
        for (int i = 1; i < n; i++) {
            int min = Integer.MAX_VALUE;
            for (int j = 0; j < primes.length; j++) {
                min = Math.min(min,primes[j] * ugly[times[j]]);
            }
            ugly[i] = min;
            
            //add times
        for (int j = 0; j < primes.length; j++) {
                if (primes[j] * ugly[times[j]] == min) {
                    times[j]++;
                }
            }
        }
            
        return ugly[n - 1];
    }
}