264. 丑数 II

264. 丑数 II

题目描述

给你一个整数 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 的大小。