leetcode刷题36——丑数系列-优快云博客

本文链接：https://blog.youkuaiyun.com/taifyang/article/details/116150546

本文介绍了丑数的基本概念及其不同变种：判断丑数、寻找第n个丑数、考虑特定因子的丑数和超级丑数的计算。通过实例展示了如何利用递归、三指针、动态规划和C++标准库解决这些问题，适合深入理解质因数分解与算法优化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.丑数
给你一个整数 n ，请你判断 n 是否为丑数。如果是，返回 true ；否则，返回 false 。
丑数就是只包含质因数 2、3 和/或 5 的正整数。

class Solution {
public:
    bool isUgly(int n) {
        if(n==0)    return false;
        while(n!=1)
        {
            if(n%5==0)  n/=5;
            else if(n%3==0)  n/=3;
            else if(n%2==0)  n/=2;
            else return false;
        }
        return true;
    }
};

2.丑数 II
给你一个整数 n ，请你找出并返回第 n 个丑数。
丑数就是只包含质因数 2、3 和/或 5 的正整数。
考察知识点：三指针

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int> dp(n);
        dp[0]=1;
        int p2=0,p3=0,p5=0;
        for(int i=1;i<n;++i)
        {
            int num2=dp[p2]*2,num3=dp[p3]*3,num5=dp[p5]*5;
            dp[i]=min(num2,min(num3,num5));
            if(dp[i]==num2) ++p2;
            if(dp[i]==num3) ++p3;
            if(dp[i]==num5) ++p5;
        }
        return dp[n-1];
    }
};

3.丑数 III
给你四个整数：n 、a 、b 、c ，请你设计一个算法来找出第 n 个丑数。
丑数是可以被 a 或 b 或 c 整除的正整数。
思路：二分查找，C++17已经在里定义了最大公约数std::gcd和最小公倍数std::lcm。
小于等于某个整数的丑数个数很好计算，即n/a+n/b+n/c-n/ab的最小公倍数-n/ac的最小公倍数-n/bc的最小公倍数+n/三者的最小公倍数。
只需要在解空间内二分找到一个整数ans，使得[1, ans]内恰好有n个丑数，ans即为第n个丑数。

class Solution {
public:
    int nthUglyNumber(int n, int a, int b, int c) {
        long lcm_ab = lcm<long>(a, b);
        long lcm_ac = lcm<long>(a, c);
        long lcm_bc = lcm<long>(b, c);
        long lcm_abc = lcm<long>(lcm_ab, c);
        int lo = min({a, b, c}), hi = lo * n;
        while (lo <= hi) 
        {
            int mid = lo + (hi - lo) / 2;  //int mid = (hi + lo) / 2; 可能会越界
            if (mid / a + mid / b + mid / c - mid / lcm_ab - mid / lcm_ac - mid / lcm_bc + mid / lcm_abc < n) 
                lo = mid + 1;
            else 
                hi = mid - 1;
        }
        return lo;
    }
};

4.超级丑数
编写一段程序来查找第 n 个超级丑数。
超级丑数是指其所有质因数都是长度为 k 的质数列表 primes 中的正整数。
考察知识点：动态规划、n指针

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        vector<int> dp(n);
        dp[0]=1;
        vector<int> factor(primes.size(),0);
        for(int i=1;i<n;++i)
        {
            int minval=INT_MAX;
            for(int j=0;j<primes.size();++j)
            {
                minval=min(minval,dp[factor[j]]*primes[j]);
            }
            for(int j=0;j<primes.size();++j)
            {
                if(minval==dp[factor[j]]*primes[j]) ++factor[j];
            }
            dp[i]=minval;
        }
        return dp[n-1];
    }
};

或者

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        vector<int> dp(n);
        dp[0]=1;
        vector<int> factor(primes.size(),0);
        for(int i=1;i<n;++i)
        {
            dp[i]=dp[factor[0]]*primes[0];
            for(int j=0;j<primes.size();++j)
            {
                dp[i]=min(dp[i],dp[factor[j]]*primes[j]);
            }
            for(int j=0;j<primes.size();++j)
            {
                if(dp[i]==dp[factor[j]]*primes[j]) ++factor[j];
            }
        }
        return dp[n-1];
    }
};