丑数 II（力扣笔记）

原题（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，以此类推。
$$dp[i]=min(dp[p_2]\times 2,dp[p_3]\times 3,dp[p_5]\times 5)(2\le i\le 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;
    }
 };