剑指 Offer（第2版）面试题 49：丑数

剑指 Offer（第2版）面试题 49：丑数

题目来源：

1. LeetCode 264. 丑数 II
2. AcWing 62. 丑数

解法1：枚举

从 1 开始枚举，直到第 n 个丑数。

代码：

/*
 * @lc app=leetcode.cn id=264 lang=cpp
 *
 * [264] 丑数 II
 */

// @lc code=start
class Solution
{
public:
    int nthUglyNumber(int n)
    {
        if (n <= 0)
            return 0;
        int number = 0, countUgly = 0;
        while (countUgly < n)
        {
            number++;
            if (isUgly(number))
                countUgly++;
        }
        return number;
    }
    bool isUgly(int n)
    {
        if (n <= 0)
            return false;
        if (n == 1)
            return true;

        if (n % 5 == 0)
            return isUgly(n / 5);
        if (n % 3 == 0)
            return isUgly(n / 3);
        if (n % 2 == 0)
            return isUgly(n / 2);

        return n == 1;
    }
};
// @lc code=end

这样太慢了，会超时。

解法2：最小堆

要得到从小到大的第 n 个丑数，可以使用最小堆实现。

初始时堆为空。首先将最小的丑数 1 加入堆。

每次取出堆顶元素 x，则 x 是堆中最小的丑数，由于 2x、3x、5x 也是丑数，因此将 2x、3x、5x 加入堆。

上述做法会导致堆中出现重复元素的情况。为了避免重复元素，可以使用哈希集合去重，避免相同元素多次加入堆。

在排除重复元素的情况下，第 n 次从最小堆中取出的元素即为第 n 个丑数。

代码：

/*
 * @lc app=leetcode.cn id=264 lang=cpp
 *
 * [264] 丑数 II
 */

// @lc code=start
class Solution
{
private:
    const vector<int> factors = {2, 3, 5};

public:
    int nthUglyNumber(int n)
    {
        if (n <= 0)
            return 0;
        // 小根堆，最小值在堆顶
        priority_queue<long, vector<long>, greater<long>> minHeap;
        unordered_set<long> uglyNumbers;
        // 1 是第一个丑数
        int ans = 0;
        uglyNumbers.insert(1L);
        minHeap.push(1L);
        for (int i = 0; i < n; i++)
        {
            long curUglyNumber = minHeap.top();
            ans = (int)curUglyNumber;
            minHeap.pop();
            for (const int factor : factors)
            {
                long nextUglyNumber = curUglyNumber * factor;
                if(!uglyNumbers.count(nextUglyNumber))
                {
                    uglyNumbers.insert(nextUglyNumber);
                    minHeap.push(nextUglyNumber);
                }
            }
        }
        return ans;
    }
};
// @lc code=end

复杂度分析：

时间复杂度：O(nlogn)，得到第 n 个丑数需要 n 次循环。每次循环都要从最小堆中取出 1 个元素和插入最多 3 个元素，因此每次循环的时间复杂度是 O(log(3n) + 3 * log(3n)) = O(logn)，总时间复杂度是 O(nlogn)。

空间复杂度：O(n)。空间复杂度主要取决于最小堆和哈希集合的大小，最小堆和哈希集合的大小都不会超过 3n。

解法3：三路归并

三指针的思想，所以定义 3 个指针 p2、p3、p5。

vector 存储的是丑数数组，一开始只有 1 个 1，后面动态添加元素进 vector。

t 取出的是 3 个指针分别指向的 3 个子数组（2、3、5）中的最小值。如果最小值是 3 个子数组中的哪一个，就把对应的指针 p2、p3、p5 增 1。

因为可能同时出现在多个相等，所以用 3 个 if 来判断、去重。

循环 n 次，最后输出 vector 的最后一位，就是第 n 个丑数。

代码：

// 三路归并

class Solution
{
public:
    int nthUglyNumber(int n)
    {
        if (n <= 0)
            return 0;
        vector<int> res(1, 1);
        int p2 = 0, p3 = 0, p5 = 0;
        while (res.size() < n)
        {
            int t = min(2 * res[p2], min(3 * res[p3], 5 * res[p5]));
            res.emplace_back(t);
            if (2 * res[p2] == t)
                p2++;
            if (3 * res[p3] == t)
                p3++;
            if (5 * res[p5] == t)
                p5++;
        }
        return res.back();
    }
};

也可以写成动态规划，思路一样的：

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)，需要计算数组 res 或 dp 的第 n 个元素，每个元素的计算都可以在 O(1) 的时间内完成。

空间复杂度：O(n)。空间复杂度主要取决于数组 res 或 dp 的大小。