【LeetCode】丑数系列

一.判断一个数是否为丑数

丑数就是只包含质因数 2, 3, 5 的正整数。
示例1:

输入: 6
输出: true
解释: 6 = 2 × 3

示例2:

输入: 14
输出: false 
解释: 14 不是丑数，因为它包含了另外一个质因数 7。

说明：

1. 1 是丑数。
2. 输入不会超过 32 位有符号整数的范围: [−231, 231 − 1]。

Java代码如下：

class Solution {
    public boolean isUgly(int num) {
        if(num == 0) return false;
        while(num % 2 == 0) num /= 2;
        while(num % 3 == 0) num /= 3;
        while(num % 5 == 0) num /= 5;
        if(num == 1) return true;
        else return false;
    }
}

二.找出第n个丑数

丑数就是只包含质因数 2, 3, 5 的正整数
示例：

输入: n = 10
输出: 12
解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。

说明：

1. 1 是丑数。
2. n 不超过1690。

Java代码如下：

class Solution {
    public int nthUglyNumber(int n) {
        int[] ugly = new int[n];
        ugly[0] = 1;
        int num2 = 0;
        int num3 = 0;
        int num5 = 0;
        for(int i = 1; i < n; i++){
            ugly[i] = Math.min(Math.min(ugly[num2]*2, ugly[num3]*3), ugly[num5]*5);
            if(ugly[i] == ugly[num2]*2) num2++;
            if(ugly[i] == ugly[num3]*3) num3++;
            if(ugly[i] == ugly[num5]*5) num5++;
        }
        
        return ugly[n-1];
    }
}

三.超级丑数

编写一段程序来查找第 n 个超级丑数。
超级丑数是指其所有质因数都是长度为 k 的质数列表 primes 中的正整数。
示例：

输入: 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] 。

说明：

• 1 是任何给定 primes 的超级丑数。

• 给定 primes 中的数字以升序排列。

• 0 < k ≤ 100, 0 < n ≤ 106, 0 < primes[i] < 1000 。

• 第 n 个超级丑数确保在 32 位有符整数范围内。

**解题思路：**参考“二.找出第n个丑数”
Java代码如下：

class Solution {
    public int nthSuperUglyNumber(int n, int[] primes) {
        if(n <= 0 || primes == null || primes.length == 0){
            return -1;
        }
        int[] primesLocation = new int[primes.length];
        for(int i = 0; i < primes.length; i++){
            primesLocation[i] = 0;
        }
        int[] ugly = new int[n];
        ugly[0] = 1;
        for(int i = 1; i < n; i++){
            int min = ugly[primesLocation[0]] * primes[0];
            for(int j = 1; j < primes.length; j++){
                if(ugly[primesLocation[j]] * primes[j] < min){
                    min = ugly[primesLocation[j]] * primes[j];
                }
            }
            for(int j = 0; j < primes.length; j++){
                if(ugly[primesLocation[j]] * primes[j] == min){
                    primesLocation[j] += 1;
                }
            }
            ugly[i] = min;
        }
        return ugly[n-1];
    }
}