49. 丑数

最新推荐文章于 2023-03-17 10:54:43 发布

qq_44038801

最新推荐文章于 2023-03-17 10:54:43 发布

阅读量96

点赞数

分类专栏： # 剑指offer（第2版）文章标签：动态规划 leetcode 算法

本文链接：https://blog.csdn.net/qq_44038801/article/details/121175352

版权

剑指offer（第2版）专栏收录该内容

74 篇文章 0 订阅

订阅专栏

本文介绍了如何使用动态规划和小根堆算法解决LeetCode中的剑指Offer问题49——找到第n+1个丑数。通过理解丑数的定义和递推性质，利用三个指针分别跟踪乘以2、3和5的最小丑数，实现了O(n)和O(n*logn)两种时间复杂度的解决方案。

摘要由CSDN通过智能技术生成

剑指 Offer 49. 丑数

思路：动态规划

设已知长度为n的丑数序列 $x_1,x_2,x_3,\cdots,x_n$ ，求第n+1个丑数，根据递推性质，丑数 $x_{n+1}$ 只可能为：
$f(x)=\begin{cases} x_a\times2 & {a\in[1,n]}\\ x_b\times3 & {b\in[1,n]}\\ x_c\times5 & {c\in[1,n]} \end{cases}$
丑数递推公式为：

$x_{n+1}=min(x_a\times2,x_b\times3,x_c\times5)$

由于 $x_{n+1}$ 是最接近 $x_n$ 的丑数，因此索引a, b, c满足以下条件：
$\begin{cases} x_a\times2>x_n\ge x_{a-1}\times2 &即x_a为首个乘以2后大于x_n的丑数\\ x_b\times3>x_n\ge x_{b-1}\times3 &即x_b为首个乘以3后大于x_n的丑数\\ x_c\times5>x_n\ge x_{c-1}\times5 &即x_c为首个乘以5后大于x_n的丑数 \end{cases}$
因此，设置指针a,b,c指向首个丑数，循环递推公式得到下个丑数，并每轮将对应指针+1

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int> dp(n);
        dp[0]=1;
        int a=0,b=0,c=0;
        for(int i=1;i<n;++i){
            int na=dp[a]*2;
            int nb=dp[b]*3;
            int nc=dp[c]*5;
            dp[i]=min(na,min(nb,nc));
            if(dp[i]==na)++a;
            if(dp[i]==nb)++b;
            if(dp[i]==nc)++c;
        }
        return dp[n-1];
    }
};

时间复杂度 O(n)

空间复杂度 O(n)

思路:小根堆+哈希表去重

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int> factors={2,3,5};
        unordered_set<long> seen;
        priority_queue<long,vector<long>,greater<long>> heap;
        seen.insert(1L);
        heap.push(1L);
        int ugly=0;
        for(int i=0;i<n;++i){
            long curr=heap.top();
            heap.pop();
            ugly=int(curr);
            for(int factor:factors){
                long next=curr*factor;
                if(!seen.count(next)){
                    seen.insert(next);
                    heap.push(next);
                }
            }
        }
        return ugly;
    }
};

时间复杂度 O(n*logn)

空间复杂度 O(n)