剑指offer（第二版）——丑数

最新推荐文章于 2024-09-21 16:35:48 发布

且思且行且珍惜且成长

最新推荐文章于 2024-09-21 16:35:48 发布

阅读量111

点赞数

分类专栏：剑指offer（第二版）Java详解文章标签：算法面试

本文链接：https://blog.csdn.net/qq_41866626/article/details/120549930

版权

剑指offer（第二版）Java详解专栏收录该内容

67 篇文章 2 订阅

订阅专栏

PS：《剑指offer》是很多同学找工作都会参考的一本面试指南，同时也是一本算法指南（为什么它这么受欢迎，主要应该是其提供了一个循序渐进的优化解法，这点我觉得十分友好）。现在很多互联网的算法面试题基本上可以在这里找到影子，为了以后方便参考与回顾，现将书中例题用Java实现（第二版），欢迎各位同学一起交流进步。

GitHub： https://github.com/Uplpw/SwordOffer。

剑指offer完整题目链接： https://blog.csdn.net/qq_41866626/article/details/120415258

1 题目描述

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

示例:

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

leetcode链接： 丑数（以下代码已测试，提交通过）

2 测试用例

一般是考虑功能用例，特殊（边缘）用例或者是反例，无效测试用例这三种情况。甚至可以从测试用例寻找一些规律解决问题，同时也可以让我们的程序更加完整鲁棒。

（1）功能用例：n是正数，如7，19。

（2）边缘用例：n=1，或者很大值。

（3）无效用例：n<=0。

3 思路

分析：

下面给出两种解决办法。

解法1：

遍历所有正整数，每遇到一个数判断是否为丑数，如果是丑数，计数加1，直到为n。（leetcode会超时）

解法2：

方法1会出现大量无效计算不是丑数的数字，导致时间效率不是很好。因此我们是不是可以直接利用丑数特点直接计算所有从小到大的丑数？这样就可以不用计算不是丑数的数字了。

自然是可以的，具体过程如下：

因为每个丑数都可以看成是由1去乘以2、3、5，再乘以2、3、5而衍生出来的。可以用三个指针指向第一个丑数1，三个指针分别表示乘2，乘3，乘5，将三个指针计算出来的最小的丑数放在数组中，并将该指针向后移动一个位置。为了得到第1500个丑数，需要一个长度1500的数组来记录已经计算出来的丑数。因此这个思路也可以说是用空间换时间。

4 代码

算法实现：

public class Ugly {
    // 解法1：遍历
    public static int getUglyNumber(int num) {
        if (num <= 0)
            return 0;
        if(num==1){
            return 1;
        }
        int ugly = 0;
        int count = 1;
        for (int i = 2; i < Integer.MAX_VALUE; i++) {
            if (isUgly(i)) {
                count++;
                if (count == num) {
                    ugly = i;
                    break;
                }
            }
        }
        return ugly;
    }

    public static boolean isUgly(int num) {
        while (true) {
            if (num % 2 == 0) {
                num /= 2;
                if (num == 1) {
                    return true;
                }
            } else if (num % 3 == 0) {
                num /= 3;
                if (num == 1) {
                    return true;
                }
            } else if (num % 5 == 0) {
                num /= 5;
                if (num == 1) {
                    return true;
                }
            } else {
                return false;
            }
        }
    }

    // 解法2：直接计算丑数
    public static int getUglyNumber1(int num) {
        if (num <= 0)
            return 0;
        int[] dp = new int[num];
        // 第一个丑数
        dp[0] = 1;
        // 分别计算当前丑数有多少个2，3，5相乘组成
        int mul2 = 0;
        int mul3 = 0;
        int mul5 = 0;
        for (int i = 1; i < num; i++) {
            // 计算前面三个丑数乘以2，3，5后哪个最小。
            dp[i] = min(dp[mul2] * 2, dp[mul3] * 3, dp[mul5] * 5);
            // 2*3=6，3*2=6，会有重复值
            if (dp[mul2] * 2 == dp[i]) {
                mul2++;
            }
            if (dp[mul3] * 3 == dp[i]) {
                mul3++;
            }
            if (dp[mul5] * 5 == dp[i]) {
                mul5++;
            }
        }
        return dp[num - 1];
    }

    public static int min(int a, int b, int c) {
        int x = a > b ? b : a;
        return x > c ? c : x;
    }

    public static void main(String[] args) {
        int num = 1352;
        System.out.println(getUglyNumber(num));
        System.out.println(getUglyNumber1(num));
    }
}