关于丑数的三道算法题

丑数

例题一：判断是否为丑数——遍历

给你一个整数 n ，请你判断 n 是否为 丑数 。如果是，返回 true ；否则，返回 false 。

丑数 就是只包含质因数 2、3 和/或 5 的正整数。

class Solution {
    public boolean isUgly(int n) {
        if(n<=0){
            return false;
        }
        int[] factors={2,3,5};
        for(int factor:factors){
            while(n%factor==0){
                n/=factor;
            }
        }
        return n==1;
    }
}

例题二：返回第n个丑数——动态规划

给你一个整数 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 通常被视为丑数。

class Solution {
    public int nthUglyNumber(int n) {
        int[] dp=new int[n+1];
        dp[1]=1;

        int[] pointers=new int[3];
        Arrays.fill(pointers,1);

        int[] primes={2,3,5};

        for(int i=2;i<=n;i++){
            int[] nums=new int[3];
            int minNum=Integer.MAX_VALUE;

            for(int j=0;j<3;j++){
                nums[j]=dp[pointers[j]]*primes[j];
                minNum=Math.min(minNum,nums[j]);
            }
            dp[i]=minNum;
            
            for(int j=0;j<3;j++){
                if(nums[j]==minNum){
                    pointers[j]++;
                }
            }
        }
        return dp[n];
    }
}

例题三：超级丑数——动态规划

超级丑数 是一个正整数，并满足其所有质因数都出现在质数数组 primes 中。

给你一个整数 n 和一个整数数组 primes ，返回第 n 个 超级丑数 。

题目数据保证第 n 个 超级丑数 在 32-bit 带符号整数范围内。

示例 1：

输入：n = 12, primes = [2,7,13,19]
输出：32
解释：给定长度为 4 的质数数组 primes = [2,7,13,19]，前 12 个超级丑数序列为：[1,2,4,7,8,13,14,16,19,26,28,32] 。

示例 2：

输入：n = 1, primes = [2,3,5]
输出：1
解释：1 不含质因数，因此它的所有质因数都在质数数组 primes = [2,3,5] 中。

class Solution {
    public int nthSuperUglyNumber(int n, int[] primes) {
        int m=primes.length;
        int[] dp=new int[n+1];
        //边界情况
        dp[1]=1;

        int[] pointers=new int[m];
        Arrays.fill(pointers,1);

        for(int i=2;i<=n;i++){
            int minNum=Integer.MAX_VALUE;
            int[] nums=new int[m];

            for(int j=0;j<m;j++){
                nums[j]=dp[pointers[j]]*primes[j];
                minNum=Math.min(minNum,nums[j]);
            }
            dp[i]=minNum;

            for(int j=0;j<m;j++){
                if(nums[j]==minNum){
                    pointers[j]++;
                }
            }
        }
        return dp[n];
    }
}