leetcode 丑数||

难度：中等

题目：

给你一个整数 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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ugly-number-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

自己的想法：中规中矩，每一个步骤都不少，导致运行了大量无用的代码，最终导致运行超时。

自己的代码：

class Solution {
public:
    bool isZhishu(int num1){//这个函数用来判断是不是质数
        int a = sqrt(num1);
        for(int i = 2;i<=a+1;i++){
            if(num1 % i == 0){
                return false;
            }
        }
        return true;
    }
    bool isUgly(int num2){//这个函数用来判断是不是丑数
        if(num2 == 1){
            return true;
        }
        if(isZhishu(num2) && num2!=2 && num2!=3 && num2!=5){
            return false;
        }
        int a = sqrt(num2);
        for(int i = 2;i<=a;i++){
            if(num2%i == 0  && i != 2 && i!=3 &&i != 5){
                if(isZhishu(i)){
                    return false;
                }
            }
        if(num2%(num2/i) == 0  && (num2/i) != 2 && (num2/i)!=3 &&(num2/i) != 5){
                if(isZhishu((num2/i))){
                    return false;
                }
            }
        }
        return true;
    }
    int nthUglyNumber(int n) { 
        int count = 0;
        int num = 1;
        while(true){
                if(isUgly(num++)){
                    count++;
                }
            if(count == n){
                break;
            }
        }
    return num-1;
    }
};

超时的原因分析：因为我大量调用了isZhiShu()这个函数，导致做了很多的无用功，改良的方法应该是在调用isZhiShu之前先加一个判断语句，用做到调用最少的子函数。……算了，感觉找半天也没找出来，下面是我的改良版本：

class Solution {
public:
    bool isZhishu(int num1){//这个函数用来判断是不是质数
        int a = sqrt(num1);
        for(int i = 2;i<=a+1;i++){
            if(num1 % i == 0){
                return false;
            }
        }
        return true;
    }
    bool isUgly(int num2){//这个函数用来判断是不是丑数
        if(num2 == 1){
            return true;
        }
        if(num2 <= 6){
            return true;
        }
       // if(isZhishu(num2) && num2!=2 && num2!=3 && num2!=5){
        //    return false;
        //}
        int a = sqrt(num2);
        int flag_s = 0;
        for(int i = 2;i<=a;i++){
            if(num2%i == 0){
                flag_s++;
                if(i!=2 && i!=3 && i!=5 ){
                if(isZhishu(i)){
                    return false;
                    }
                }
            }
        if(num2%(num2/i) == 0  && (num2/i) != 2 && (num2/i) != 3 && (num2/i)  !=5){
                if(isZhishu((num2/i))){
                    return false;
                }
            }
        }
        if(flag_s == 0 && flag_s != 2 && flag_s != 3 && flag_s != 5){
            return false;
        }
        return true;
    }
    int nthUglyNumber(int n) { 
        int count = 0;
        int num = 1;
        while(true){
                if(isUgly(num++)){
                    count++;
                }
            if(count == n){
                break;
            }
        }
    return num-1;
    }
};

唉……确实改良了，但是就多通过了几个案例而已！！！！！

我还是看看大佬是怎么做的吧.>_<.

大佬之方法一：最小堆

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

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

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

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

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

点这里看详细

核心思想就是直接去找所有的丑数，这种做法可以在目标数目相对与所有的数据集来说比较少的情况。但是确实是很好的思想，启发了我反向思考问题的能力。

第二种方法是动态规划，详细也在上面那个链接里面。每日一句，我好菜……