持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第23天，点击查看活动详情

动态规划(Dynamic Programming)是一种分阶段求解决策问题的数学思想,它通过把原问题分解为简单的子问题来解决复杂问题。

超级丑数

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

动态规划

第 n 个超级丑数是基于 前面某一个超级丑数乘以某一个 primes[i] 得到的（注意：只需要乘以某一个质数），基于这一点（递推关系），可以使用「动态规划」。

定义dp[i] 表示第 i + 1 个超级丑数，第 1 个超级丑数是 dp[0]，第 2 个超级丑数是 dp[1]，由于最小的超级丑数是 1，因此 dp[1]=1。

创建与数组 primes 相同长度的数组 pointers，表示下一个超级丑数是当前指针指向的超级丑数乘以对应的质因数。初始时，数组 pointers 的元素值都是 1。

fun nthSuperUglyNumber(n: Int, primes: IntArray): Int {
    val pLen = primes.size
    val indexes = IntArray(pLen)
    val dp = IntArray(n)
    dp[0] = 1
    for (i in 1 until n) {
        dp[i] = Int.MAX_VALUE
        for (j in 0 until pLen) {
            dp[i] = Math.min(dp[i], dp[indexes[j]] * primes[j])
        }
        for (j in 0 until pLen) {
            if (dp[i] == dp[indexes[j]] * primes[j]) {
                indexes[j]++
            }
        }
    }
    return dp[n - 1]
}

复杂度分析

• 时间复杂度：O(nm)，这里 n 就是题目中的 n，m 是质数数组的长度，外层循环次 n，内层循环遍历了 2 次质数数组。
• 空间复杂度：O(n + m)。