【算法修炼】丑数系列

丑数的判定很简单，只需要看是否能被2或者3或者5的质因数除尽。

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

dp[i]代表第 i 个丑数，dp[1]=1，后续的丑数都必须由前面的丑数 * 2 或者 * 3 或者 * 5得到，所以可以用三个指针分别指向2、3、5三个质因数对应的dp中的丑数位置。每次都取三者中最小的丑数放入dp数组。还需要注意为了避免重复记录丑数，不要使用if-else结构。

class Solution {
    public int nthUglyNumber(int n) {
        int[] dp = new int[n + 1];
        dp[1] = 1;
        int p2 = 1, p3 = 1, p5 = 1;
        for (int i = 2; i <= n; i++) {
            int num2 = dp[p2] * 2, num3 = dp[p3] * 3, num5 = dp[p5] * 5;
            dp[i] = Math.min(num2, Math.min(num3, num5));
            // 不能写成if-else形式，因为当dp[i]=6时，可以由p2、p3产生
            // 为避免重复记录丑数，需要让p2 p3都++
            if (dp[i] == num2) p2++;
            if (dp[i] == num3) p3++;
            if (dp[i] == num5) p5++;
        }
        return dp[n];
    }
}

是上一题的升级版，质因数不再是2 3 5，而是有给定的primes，和上一题一样的思路，有几个primes就设定几个指针，分别记录质因数为primes[0] primes[1] … 的在dp数组中需要乘的系数的位置。

class Solution {
    public int nthSuperUglyNumber(int n, int[] primes) {
        int[] dp = new int[n + 1];
        dp[1] = 1;
        int m = primes.length;
        // m个质因数，对应m个指针
        int[] idx = new int[m];
        Arrays.fill(idx, 1);
        for (int i = 2; i <= n; i++) {
            int min = Integer.MAX_VALUE;
            for (int j = 0; j < m; j++) {
                min = Math.min(min, primes[j] * dp[idx[j]]);
            }
            dp[i] = min;
            for (int j = 0; j < m; j++) {
                if (primes[j] * dp[idx[j]] == min) idx[j]++;
            }
        }
        return dp[n];
    }
}