剑指offer面试题49-丑数

一.题目描述

我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。

示例:

输入: n = 10
输出: 12
解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。
说明:

1 是丑数。
n 不超过1690。

二.题目解析

1.直观的解法，缺点是对于非丑数也做了大量计算

public int nthUglyNumber(int n) {
        /*超时*/
        int i = 0;
        int res = 0;
        while(i < n){
            res++;
            if(isUgly(res)){
                i++;
            }
        }
        return res;
    }
    private boolean isUgly(int n){
        //如果能被2整除，就连续的除
        while(n % 2 == 0){
            n /= 2;
        }
        //如果能被3整除，就连续的除
        while(n % 3 == 0){
            n /= 3;
        }
        //如果能被5整除，就连续的除
        while(n % 5 == 0){
            n /= 5;
        }
        return n == 1 ? true : false;
    }

2.为了避免在1中的在非丑数上花费时间

public int nthUglyNumber1(int n) {
        /*创建数组保存排好序的丑数，根据丑数定义，丑数应该是另一个丑数乘以2,3或者5的结果（1除外）
        * 假设已有的最大丑数是M，那么下一个最大丑数可能在，数组已有元素中第一个乘以2后大于M的值，
        * 第一个乘以3后大于M的值，第一个乘以5后大于M的值，这三者之间产生
        * 时间复杂度O(n),空间复杂度O(n)
        * */
        if(n <= 0){
            return 0;
        }
        //*数组大小是n,不是n-1
        int[] res = new int[n];
        res[0] = 1;

        int valOf2 = 0;
        int valOf3 = 0;
        int valOf5 = 0;
        int index = 0;
        while(index < n - 1){
            //下一个丑数是三者中的最小值
            int min = (res[valOf2] * 2 < res[valOf3] * 3 ? res[valOf2] * 2 : res[valOf3] * 3) < res[valOf5] * 5 ? (res[valOf2] * 2 < res[valOf3] * 3 ? res[valOf2] * 2 : res[valOf3] * 3) : res[valOf5] * 5;
            index++;
            res[index] = min;
            //下面是计算新的位置
            for (int i = valOf2; i <= index; i++) {
                if(res[i] * 2 > res[index]){
                    valOf2 = i;
                    break;
                }
            }
            for (int i = valOf3; i <= index; i++) {
                if(res[i] * 3 > res[index]){
                    valOf3 = i;
                    break;
                }
            }
            for (int i = valOf5; i <= index; i++) {
                if(res[i] * 5 > res[index]){
                    valOf5 = i;
                    break;
                }
            }

        }
        return res[n - 1];
    }

3.动态规划

public int nthUglyNumber2(int n) {
        /*动态规划，设置3个索引a, b, c，分别记录前几个数已经被乘2， 乘3， 乘5了，
        比如a表示前(a-1)个数都已经乘过一次2了，下次应该乘2的是第a个数；
        b表示前(b-1)个数都已经乘过一次3了，下次应该乘3的是第b个数；
        c表示前(c-1)个数都已经乘过一次5了，下次应该乘5的是第c个数；
         * 时间复杂度O(n),空间复杂度O(n)
         * */
        int[] dp = new int[n];  // 使用dp数组来存储丑数序列
        dp[0] = 1;  // dp[0]已知为1
        int a = 0, b = 0, c = 0;    // 下个应该通过乘2来获得新丑数的数据是第a个， 同理b, c

        for(int i = 1; i < n; i++){
            // 第a丑数个数需要通过乘2来得到下个丑数，第b丑数个数需要通过乘2来得到下个丑数，同理第c个数
            int n2 = dp[a] * 2, n3 = dp[b] * 3, n5 = dp[c] * 5;
            dp[i] = Math.min(Math.min(n2, n3), n5);
            //注意：如果第a个数乘2后等于第b个数乘3，或者等于第c个数乘5，
            // 说明这个新的丑数是有两种或者三种方式可以得到，这时应该给得到这个新丑数的组合对应的索引都加一
            //所以三个if应该并列
            if(dp[i] == n2){
                a++; // 第a个数已经通过乘2得到了一个新的丑数，那下个需要通过乘2得到一个新的丑数的数应该是第(a+1)个数
            }
            if(dp[i] == n3){
                b++; // 第 b个数已经通过乘3得到了一个新的丑数，那下个需要通过乘3得到一个新的丑数的数应该是第(b+1)个数
            }
            if(dp[i] == n5){
                c++; // 第 c个数已经通过乘5得到了一个新的丑数，那下个需要通过乘5得到一个新的丑数的数应该是第(c+1)个数
            }
        }
        return dp[n-1];
    }