【数学】丑数II 和 超级丑数

题目描述

给你一个整数 n ，请你找出并返回第 n 个 丑数 。

• 丑数 就是只包含质因数 2、3 和/或 5 的正整数。
• 提示：1也是丑数

示例 1：

输入：n = 9
输出：10
解释：[1, 2, 3, 4, 5, 6, 8, 9, 10] 是由前 9 个丑数组成的序列。

解题思路

方案一，使用优先队列+哈希表：

• 准备PriorityQueue<Long> priorityQueue用于结果排序; 和Set<Long> set 记录是否出现过数字; 
• 将1加入到priorityQueue和set中，并且新增count=1，记录添加的数字个数；
• 从priorityQueue中取最小的数字v(priorityQueue.offer())，count++, 退出条件count>=n;然后执行v2=v*2；v3=v*3；v5=v*5; 
  • 如果set中不包含v2，则把v2加入到priorityQueue中，
  • 如果set中不包含v3，则把v3加入到priorityQueue中，
  • 如果set中不包含v5，则把v5加入到priorityQueue中，
• 从priorityQueue中找到第n个数字；直接返回priorityQueue.offer();

代码实现如下：

import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Set;

class Solution1 {

    public int nthUglyNumber(int n) {

        PriorityQueue<Long> priorityQueue = new PriorityQueue<>(n * 3);
        Set<Long> set = new HashSet<>(n * 3);

        if (n == 1) {
            return 1;
        }
        priorityQueue.offer(1L);
        set.add(1L);


        int count = 1;

        while (count < n) {
            long v = priorityQueue.poll();
            long v2 = 2 * v;
            if (!set.contains(v2)) {
                priorityQueue.offer(v2);
                set.add(v2);
            }
            long v3 = 3 * v;
            if (!set.contains(v3)) {
                priorityQueue.offer(v3);
                set.add(v3);
            }
            long v5 = 5 * v;
            if (!set.contains(v5)) {
                priorityQueue.offer(v5);
                set.add(v5);
            }
            count++;
        }

        return priorityQueue.poll().intValue();
    }

    public static void main(String[] args) {
        Solution1 solution = new Solution1();
        System.out.println(solution.nthUglyNumber(10));
    }
}

---

方案二，使用动态规划，核心思路是找到数学规律：

• 准备p2,p3,p5作为2、3、5的父亲节点的下标，int dp[] = new int[n+1];
• 初始化dp[1]=1; p2=1,p3=1,p5=1;
• 从2到n做循环
  • 计算 v2=dp[p2] * 2 ; v3=dp[p3]*3 ; v5=dp[p5]*5;
  • 取v2、v3、v5中的最小值为min，并且dp[i]= min；
  • 判断: 如果min==v2 则p2++; 如果min==v3 则p3++; 如果min==v5 则p5++; 
• 直接返回dp[n];

代码实现如下：

class Solution {

    public int nthUglyNumber(int n) {
        // 使用dp
        int[] dp = new int[n + 1];
        dp[1] = 1;

        int p2 = 1;
        int p3 = 1;
        int p5 = 1;


        for (int i = 2; i <= n; i++) {
            int num2 = 2 * dp[p2];
            int num3 = 3 * dp[p3];
            int num5 = 5 * dp[p5];

            dp[i] = Math.min(Math.min(num2, num3), num5);

            if (num2 == dp[i]) {
                p2++;
            }
            // 坑点，如果是6，则p2和p3都要做自加操作
            if (num3 == dp[i]) {
                p3++;
            }
            if (num5 == dp[i]) {
                p5++;
            }
        }

        return dp[n];

    }

第二种方案耗时只有2ms，剩下的方案只能提前算出来数字存储到array里面能更快了吧。 

题目扩展-超级丑数

超级丑数 是一个正整数，并满足其所有质因数都出现在质数数组 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,3,5改造成数组计算，这样通用性更高，代码实现如下：

import java.util.Arrays;

class Solution {

    public int nthSuperUglyNumber(int n, int[] primes) {

        long[] dp = new long[n + 1];
        dp[1] = 1;

        int p[] = new int[primes.length];
        Arrays.fill(p, 1);

        long values[] = new long[primes.length];

        for (int i = 2; i <= n; i++) {
            long min = Long.MAX_VALUE;
            for (int j = 0; j < p.length; j++) {
                values[j] = primes[j] * dp[p[j]];
                min = Math.min(min, values[j]);
            }
            dp[i] = min;

            for (int j = 0; j < p.length; j++) {
                if (min == values[j]) {
                    p[j]++;
                }
            }
        }
        return (int)dp[n];
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        System.out.println(solution.nthSuperUglyNumber(10, new int[]{2, 3, 5}));
    }
}

总结

从上面第一个问题的两个解决思路，可分为传统思路和动态规划，动态规划在耗时方面真实太优秀了；但是要想到却很费脑子，我主要还是看了别人的解题思路后，自己再实现了一遍，对动态规划这块一直做的不太好。如果有更高效、更简洁的解决方案欢迎回复。