原题(264):
给你一个整数 n ,请你找出并返回第 n 个 丑数 。
丑数 就是只包含质因数 2、3 和/或 5 的正整数。
示例 1:
输入:n = 10
输出:12
解释:[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。
原题链接:原题链接
法一:直接遍历,此种方法按序遍历时间复杂度很高:
class Solution {
public:
int nthUglyNumber(int n) {
if (n == 1) return 1;
int i = 2;
while (true)
{
if (isUgly(i))
{
if (n == 2)
return i;
else
n--;
}
i++;
}
}
bool isUgly(int n) {
if(n <= 0) return false;
vector<int> factors = {2,3,5};
for (int factor : factors)
{
while (n%factor == 0)
{
n /= factor;
}
}
return n==1;
}
};
法二:三指针的动态规划,
题目所求为丑数,因此结果肯定是以2,3,5为因数的数中选(1为特殊情况),现在的问题是如何对这些数进行排序。
这里采取了动态规划的方法,
(1)状态定义:定义数组dp,其中dp[i]表示第i个丑数。
(2)状态转移方程:定义了三个指针p2,p3,p5,p2表示的是当前指针指向的丑数乘以2,以此类推。
d
p
[
i
]
=
m
i
n
(
d
p
[
p
2
]
×
2
,
d
p
[
p
3
]
×
3
,
d
p
[
p
5
]
×
5
)
(
2
≤
i
≤
n
)
.
dp[i] = min(dp[p_2]\times 2, dp[p_3]\times 3, dp[p_5]\times 5) (2\le i \le n).
dp[i]=min(dp[p2]×2,dp[p3]×3,dp[p5]×5)(2≤i≤n).
(3)状态边界条件:dp[1] =1
class Solution {
public:
int nthUglyNumber(int n) {
if(n == 1) return 1;
vector<int> dp(n+1);
dp[1] = 1;
int p2 = 1, p3 = 1, p5 = 1;
for (int i = 2;i <= n;i++)
{
dp[i] = min(min(dp[p2]*2, dp[p3]*3), dp[p5]*5);
//printf("dp[p2]*2=%d,dp[p3]*3=%d,dp[p5]=%d\n",dp[p2]*2,dp[p3]*3,dp[p5]*5);
//printf("dp[%d]=%d\n",i,dp[i]);
/*这里不能写成else if
否则会出现例如dp[p2]*2=6,dp[p3]=6的情况时,只有p2++,
正确的应该是p2++,p3++
*/
if (dp[i] == dp[p2]*2)
{
p2++;
}
if (dp[i] == dp[p3]*3)
{
p3++;
}
if (dp[i] == dp[p5]*5)
{
p5++;
}
}
return dp[n];
}
};
法三:小根堆,
先存入,再排序,注意需要进行去重,
class Solution {
public:
int nthUglyNumber3(int n) {
priority_queue <double,vector<double>,greater<double> > q;
unordered_set<int> seen;
//vector<int> factor({2,3,5});
int factor[] = {2,3,5};
double res = 1;
seen.insert(1);
if (n == 1) return 1;
for (int i = 1;i < n;i++)
{
for (int j = 0;j < 3;j++)
{
if (seen.count(res*factor[j]) == 0)
{
q.push(res*factor[j]);
seen.insert(res*factor[j]);
}
}
res = q.top();
q.pop();
}
return res;
}
};