题目
我们把只包含质因子2、3和5的数称作丑数(Ugly Number)。比如:6、8都是丑数,但14不是,因为它包含质因子7。习惯上,我们把1当做是第一个丑数。求按从小到大的顺序的第n个丑数。
示例 1:
python
输入:5
输出:5
示例 2:
python
输入:7
输出:8
暴力法
本题最直观的解法是使用暴力法,即从1开始逐个检查每个自然数是否为丑数,直到找到第n个丑数为止。使用暴力法求解本题的主要步骤如下。
1、定义一个函数,用于判断一个数是否为丑数。
2、从1开始遍历每一个数,对每个数调用该函数。
3、计数器记录已经找到的丑数的数量,当计数器达到n时,返回当前检查的数作为第n个丑数。
根据上面的算法步骤,我们可以得出下面的示例代码。
python
def is_ugly_number(num):
if num <= 0:
return False
for factor in [2, 3, 5]:
while num % factor == 0:
num //= factor
return num == 1
def find_ugly_numbers_by_brute_force(n):
count = 0
num = 1
while True:
if is_ugly_number(num):
count += 1
if count == n:
return num
num += 1
print(find_ugly_numbers_by_brute_force(5))
print(find_ugly_numbers_by_brute_force(7))
优先队列法
优先队列法利用了最小堆的数据结构来保持未处理的丑数候选,其基本思想为:初始时,我们将1加入到优先队列中,因为1是最小的丑数;之后,每次从队列中取出最小的元素,并将其与2、3、5相乘后再次加入队列中。为了避免重复加入相同的丑数,我们需要记录之前加入队列的最大值,并确保不加入小于等于该最大值的数。使用优先队列法求解本题的主要步骤如下。
1、初始化堆和已知丑数。
(1)创建一个最小堆heap,并向其中添加第一个丑数1。
(2)创建一个集合seen,用于存储已经发现的丑数,以防止重复计算。
(3)设置变量last_ugly为 1,这代表最后加入的丑数。
(4)设置计数器count为 1,用来跟踪已经找到的丑数的数量。
2、循环直到找到第n个丑数,并执行以下操作。
(1)每次循环从堆中弹出最小的丑数current,并使用三个质因数(2、3、5)分别乘以current来生成新的丑数。
(2)对于每个新生成的丑数new_ugly,检查它是否已经被计算过,即是否存在于seen集合中。
(3)如果new_ugly还未被计算过,则将其添加到seen集合中,并将其推入堆heap中。
3、更新最后加入的丑数。
(1)如果弹出的丑数current不等于last_ugly,这意味着我们找到了一个新的丑数。
(2)更新last_ugly为current,并将count加一。
(3)当count达到n时,循环结束,此时last_ugly即为第n个丑数。
4、返回last_ugly作为第n个丑数。
根据上面的算法步骤,我们可以得出下面的示例代码。
python
import heapq
def find_ugly_numbers_by_priority_queue(n):
# 初始化最小堆
heap = [1]
# 记录最后一个加入堆的丑数
last_ugly = 1
# 已找到的丑数数量
count = 1
# 使用集合来去重
seen = set([1])
while count < n:
# 弹出当前最小的丑数
current = heapq.heappop(heap)
# 生成新的丑数并加入堆中
for factor in [2, 3, 5]:
new_ugly = current * factor
# 如果新生成的丑数还没有被加入过,则加入堆中
if new_ugly not in seen:
seen.add(new_ugly)
heapq.heappush(heap, new_ugly)
# 只有在当前丑数不等于最后一个加入的丑数时,才进行下一步操作
if current != last_ugly:
last_ugly = current
count += 1
# 最后一个加入的丑数就是第n个丑数
return last_ugly
print(find_ugly_numbers_by_priority_queue(5))
print(find_ugly_numbers_by_priority_queue(7))
动态规划法
使用动态规划法的关键是:定义状态转移方程。假设dp[i]表示第i个丑数,则本题的状态转移方程为:dp[i] = min(2 * dp[j], 3 * dp[k], 5 * dp[l])。其中,j、k、l分别表示最近乘以2、3、5得到dp[i]的索引。边界条件为dp[1] = 1,因为1是最小的丑数。使用动态规划法求解本题的主要步骤如下。
1、初始化数组dp,长度为n + 1,其中dp[1] = 1。
2、定义三个指针j、k、l,初始值均为1。
3、对于每个i(从2到n),进行以下操作。
(1)计算dp[i]的值,它是2 * dp[j]、3 * dp[k]、5 * dp[l]中的最小值。
(2)如果dp[i]等于2 * dp[j],则j加1。
(3)如果dp[i]等于3 * dp[k],则k加1。
(4)如果dp[i]等于5 * dp[l],则l加1。
4、当i达到n时,dp[n]就是第n个丑数。
根据上面的算法步骤,我们可以得出下面的示例代码。
python
def find_ugly_numbers_by_dp(n):
if n == 1:
return 1
# 初始化dp数组
dp = [0] * (n + 1)
dp[1] = 1
j, k, l = 1, 1, 1
for i in range(2, n + 1):
# 计算下一个丑数
dp[i] = min(2 * dp[j], 3 * dp[k], 5 * dp[l])
# 更新指针
if dp[i] == 2 * dp[j]:
j += 1
if dp[i] == 3 * dp[k]:
k += 1
if dp[i] == 5 * dp[l]:
l += 1
return dp[n]
print(find_ugly_numbers_by_dp(5))
print(find_ugly_numbers_by_dp(7))
总结
暴力法的实现较为简单,但效率低下,尤其是在n较大的时候。最坏情况下,需要检查所有的数直到找到第n个丑数。假设第n个丑数是u(n),则暴力法的时间复杂度为O(u(n))。其空间复杂度为O(1),只需要常数级别的额外空间。
使用优先队列法时,插入和删除操作的时间复杂度为O(logu(n)),且需要做n次这样的操作,故总的时间复杂度为O(n*logu(n))。堆的大小最多为u(n),故总的空间复杂度为O(u(n))。与暴力法相比,优先队列法的效率更高,但可能带来较多的空间消耗。
使用动态规划法时,每个数只被访问一次,故时间复杂度为O(n)。其空间复杂度也为O(n),因为仅需要一个长度为n的数组来存储结果。动态规划法在时间和空间上都较为平衡,故实际应用中,通常倾向于使用动态规划法来解决这类问题。