超级丑陋数 Super Ugly Number

2019独角兽企业重金招聘Python工程师标准>>>

问题：

Write a program to find the nth super ugly number.

Super ugly numbers are positive numbers whose all prime factors are in the given prime list primes of size k. For example, [1, 2, 4, 7, 8, 13, 14, 16, 19, 26, 28, 32] is the sequence of the first 12 super ugly numbers given primes = [2, 7, 13, 19] of size 4.

Note:
(1) 1 is a super ugly number for any given primes.
(2) The given numbers in primes are in ascending order.
(3) 0 < k ≤ 100, 0 < n ≤ 106, 0 < primes[i] < 1000.
(4) The nth super ugly number is guaranteed to fit in a 32-bit signed integer.

解决：

【题意】找到第n个超级丑陋数。

超级丑陋数是一个素数，其所有的素数因子都在给定的素数列表中。

例如：[1, 2, 4, 7, 8, 13, 14, 16, 19, 26, 28, 32]是前12个超级丑陋数的序列，其所有素数因子都在给定的素数列表[2,7,13,19]中，其大小为4.

https://segmentfault.com/a/1190000004187449

① 动态规划。由丑陋数的定义我们可以知道，除了第一个数字，其余所有数字都是之前已有数字乘以任意一个在素数数组里的素数。例如，素数列表为[2,7,13,19]，结果为7。

由于我们不知道质数的个数，我们可以用一个index数组来保存当前的位置，然后我们从每个子链中取出一个数，找出其中最小值，然后更新index数组对应位置。

注意对于已有序列中的数，乘不同质数得到的结果会可能存在重复，比如题目中例子2, 7与7, 2就重复了，解决方法很简单，就是只要是等于最小的结果，就增加对应index数组中的元素。

设dp[i]代表第i个Super Ugly Number，index[i]表示第i个质数应该和第几个质数相乘。

class Solution {//26ms
    public static int nthSuperUglyNumber(int n, int[] primes) {
        int[] index = new int[primes.length];//丑陋数结果集中下一个要与超级丑陋数相乘的数的下标
        int[] res = new int[n];//保存超级丑陋数
        res[0] = 1;
        for (int i = 1;i < n;i ++){
            int min = Integer.MAX_VALUE;
             for (int j = 0;j < primes.length;j ++){
                int tmp = primes[j] * res[index[j]];
                if (min > primes[j] * res[index[j]]){
                    min = primes[j] * res[index[j]];
                }
            }
            for (int j = 0;j < primes.length;j ++){//如果已经存储到丑陋数结果集中，更新数组下标的位置
                 if (min == primes[j] * res[index[j]]){
                     index[j] ++;
                 }
            }
            res[i] = min;
        }
        return res[n - 1];
    }
}

② 在discuss中看到的。跟上面是相同的思路。

class Solution { //19ms
    public int nthSuperUglyNumber(int n, int[] primes) {
        int[] dp = new int[n];
        int[] index = new int[primes.length];
        dp[0] = 1;//所有的素数列表都包含该超级丑陋数
        for (int i = 1;i < n;i ++){
            int min = Integer.MAX_VALUE;
            int tmpindex = 0;
            for (int j = 0;j < primes.length;j ++){
                int cur = dp[index[j]] * primes[j];
                if (cur < min){
                    min = cur;
                    tmpindex = j;
                }else if (cur == min){
                    index[j] ++;
                }
            }
            index[tmpindex] ++;
            dp[i] = min;
        }
        return dp[n - 1];
    }
}

转载于:https://my.oschina.net/liyurong/blog/1594200