题目描述
给你一个整数 n ,请你找出并返回第 n 个 丑数 。
丑数 就是只包含质因数 2、3 和/或 5 的正整数。
示例 1:
输入:n = 10
输出:12 解释:[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。
示例 2:
输入:n = 1
输出:1
解释:1 通常被视为丑数。
提示:
1 <= n <= 1690
方法一:暴力法
//连暴力法都没看懂
//暴力法
class Solution{
public:
int nthUglyNumber(int n){
vector<int> v;
for(long long a=1;a<=INT_MAX;a=a*2)
for(long long b=a;b<=INT_MAX;b=b*3)
for(long long c=b;c<=INT_MAX;c=c*5)
v.push_back(c);
sort(v.begin(),v.end());
return v.at(n-1);
}
};
方法二:最小堆
要得到从小到大的第 nn 个丑数,可以使用最小堆实现。
初始时堆为空。首先将最小的丑数 11 加入堆。
每次取出堆顶元素 x,则 x 是堆中最小的丑数,由于 2x, 3x, 5x 也是丑数,因此将 2x, 3x, 5x 加入堆。
上述做法会导致堆中出现重复元素的情况。为了避免重复元素,可以使用哈希集合去重,避免相同元素多次加入堆。
在排除重复元素的情况下,第 n 次从最小堆中取出的元素即为第 n 个丑数。
C++代码
//既然priority_queue是队列,那么先要包含头文件#include <queue>
//priority_queue和queue不同的就在于我们可以自定义其中数据的优先级, 让优先级高的排在队列前面,优先出队
class Solution
{
public:
int nthUglyNumber(int n)
{
vector<int> factors = { 2,3,5 };
unordered_set<long> seen;//unorder版本的map和set只提供前向迭代器 在一个unordered_set内部,元素不会按任何顺序排序,而是通过元素值的hash值将元素分组放置到各个槽(Bucker,也可以译为“桶”),这样就能通过元素值快速访问各个对应的元素(均摊耗时为O(1))。
//priority_queue<Type, Container, Functional>//Functional是仿函数
priority_queue<long, vector<long>, greater<long>> heap;//greater<long>表明是一个升序队列,小顶堆。//队列也是堆
seen.insert(1L);//堆//1L表明插入的1是long类型的。//1是丑数,提前插入unodered_set中
heap.push(1L);//堆
int ugly = 0;
for (int i = 0; i < n; i++)
{
long curr = heap.top();//heap是先进先出,每次取出堆顶元素x,则x是堆中最小的丑数
heap.pop();
ugly = (int)curr;//long->int
for (int factor : factors)
{
long next = curr*factor;//有且仅有丑数的 2x,3x,5x 是丑数,因此将 2x,3x,5x 加入堆。
//unodered_set去除第二次出现的数
if (!seen.count(next))//unordered_set::count()函数是C++ STL中的内置函数,用于对unordered_set容器中特定元素的出现进行计数。由于unordered_set容器不允许存储重复的元素,因此该功能通常用于检查容器中是否存在元素。如果元素存在于容器中,则该函数返回1,否则返回0。
{
seen.insert(next);
heap.push(next);//push(const T& obj):将obj的副本放到容器的适当位置,这通常会包含一个排序操作。这也是priority_queue与普通queue的区别。
}
}
}
return ugly;
}
};
上述代码的关键点有且仅有丑数的 2x,3x,5x 是丑数,因此将丑数的 2x,3x,5x 加入堆(x代表倍数)。
所以由已知的的丑数可以推导出所有丑数,从小到大的丑数的2x,3x,5x必定是丑数,但是这中间会有重复的数,所以要用unordered_set去重。
时间复杂度:O(nlogn)。得到第 n 个丑数需要进行 n 次循环,每次循环都要从最小堆中取出 1 个元素以及向最小堆中加入最多 3 个元素,因此每次循环的时间复杂度是O(logn+log3n)=O(logn),总时间复杂度是 O(nlogn)。
空间复杂度:O(n)。空间复杂度主要取决于最小堆和哈希集合的大小,最小堆和哈希集合的大小都不会超过 3n。
方法三:动态规划
//似懂非懂
方法二使用最小堆,会预先存储较多的丑数,导致空间复杂度较高,维护最小堆的过程也导致时间复杂度较高。可以使用动态规划的方法进行优化。
我们先模拟手写丑数的过程
1 打头,1 乘 2 1 乘 3 1 乘 5,现在是 {1,2,3,5}
轮到 2,2 乘 2 2 乘 3 2 乘 5,现在是 {1,2,3,4,5,6,10}
手写的过程和采用小顶堆的方法很像,但是怎么做到提前排序呢
小顶堆的方法是先存再排,dp 的方法则是先排再存
我们设 3 个指针 p2,p3,p5代表的是第几个数的2倍、第几个数 3 倍、第几个数 5 倍
动态方程 dp[i]=min(dp[p2]*2,dp[p3]*3,dp[p5]*5)
小顶堆是一个元素出来然后存 3 个元素
动态规划则是标识 3 个元素,通过比较他们的 2 倍、3 倍、5 倍的大小,来一个一个存
class Solution
{
public:
int nthUglyNumber(int n)
{
vector<int> dp(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] = min(min(num2, num3), num5);
if (dp[i] == num2)
{
p2++;
}
if (dp[i] == num3)
{
p3++;
}
if (dp[i] == num5)
{
p5++;
}
}
return dp[n];
}
};
复杂度分析
时间复杂度:O(n)。需要计算数组 dp 中的 n 个元素,每个元素的计算都可以在 O(1) 的时间内完成。
空间复杂度:O(n)。空间复杂度主要取决于数组 dp 的大小。