263. 丑数

文章目录

• [263. 丑数](https://leetcode.cn/problems/ugly-number/)
• [264. 丑数 II](https://leetcode.cn/problems/ugly-number-ii/)
• [1201. 丑数 III](https://leetcode.cn/problems/ugly-number-iii/)
• [313. 超级丑数](https://leetcode.cn/problems/super-ugly-number/)

263. 丑数

class Solution:
    def isUgly(self, n: int) -> bool:
        if n <= 0: return False
        for factor in [2,3,5]:
            while not n % factor:
                n //= factor        
        return n == 1

264. 丑数 II

class Solution:
    def nthUglyNumber(self, n: int) -> int:
        factors = [2, 3, 5]
        seen = {1}
        q = [1]
        for i in range(n - 1):
            cur = heappop(q)
            for factor in factors:
                if (nxt := cur * factor) not in seen:
                    seen.add(nxt)
                    heappush(q, nxt)
        return heappop(q)

        a = b = c = 0
        dp = [1] * n        
        for i in range(1, n):
            dp[i] = min(dp[a] * 2, dp[b] * 3, dp[c] * 5)    
            if dp[i] == dp[a] * 2: a += 1
            if dp[i] == dp[b] * 3: b += 1
            if dp[i] == dp[c] * 5: c += 1 
        return dp[-1]

class Solution {
    public int nthUglyNumber(int n) {
        // PriorityQueue<Long> q = new PriorityQueue();
        // q.offer(1L);
        // int[] fact = {2, 3, 5};
        // Set<Long> vis = new HashSet();
        // for(int i = 1; i < n; i++){
        //     long cur = q.poll();           
        //     for(int f: fact){
        //         long next = f * cur;
        //         if(!vis.contains(next)){
        //             vis.add(next);
        //             q.offer(next);
        //         }
        //     }
        // }
        // return (int)(long)q.peek();
        
        int[] dp = new int[n];
        Arrays.fill(dp, 1);
        int a = 0, b = 0, c = 0;
        for(int i = 1; i < n; i++){
            dp[i] = Math.min(dp[a] * 2, Math.min(dp[b] * 3, dp[c] * 5));
            if(dp[i] == dp[a] * 2) a++;
            if(dp[i] == dp[b] * 3) b++;
            if(dp[i] == dp[c] * 5) c++;
        }
        return dp[n - 1];
    }
}

1201. 丑数 III

class Solution:
    def nthUglyNumber(self, n: int, a: int, b: int, c: int) -> int:
 
        # 最小公倍数
        # def lcm(a, b):
        #     return a * b / gcd(a, b)
        # def gcd(a, b):
        #     return a if b == 0 else gcd(b, a % b)

        x, y, z, p = lcm(a, b), lcm(a, c), lcm(b, c), lcm(a, b, c)
        def cnt(m):
            return m // a + m // b + m // c - m // x - m // y - m // z + m // p
        i, j = 1, min(a, b, c) * n 
        while i < j:
            mid = i + j >> 1
            if cnt(mid) < n: i = mid + 1
            else: j = mid
        return i

313. 超级丑数

class Solution:
    def nthSuperUglyNumber(self, n: int, primes: List[int]) -> int:
        dp = [1] * n        
        m = len(primes)
        idx = [0] * m
        for i in range(1, n):
            dp[i] = min(dp[idx[j]] * primes[j] for j in range(m))
            for j in range(m):
                if dp[i] == dp[idx[j]] * primes[j]:
                    idx[j] += 1         
        return dp[n - 1]