LeetCode：Ugly Number II - 丑数2：找出第n个丑数

最新推荐文章于 2021-07-14 09:35:04 发布
最新推荐文章于 2021-07-14 09:35:04 发布
阅读量165 收藏
点赞数
文章标签： 数据结构与算法 java
原文链接：https://my.oschina.net/Tsybius2014/blog/495962
版权

1、题目名称

Ugly Number II（丑数2：找出第n个丑数）

2、题目地址

https://leetcode.com/problems/ugly-number-ii/

3、题目内容

英文：Write a program to find the n-th ugly number.

中文：写程序找出第n个丑数

说明：丑数具有如下特征：1是丑数，丑数可以表示为有限个2、3、5的乘积

注意：关于“判断指定数字是否为丑数”，请参考Ugly Number（LeetCode #263）

5、一个TLE的方法

一个最容易想到的方法，就是从1开始依次向后判断各自然数是否为丑数，一直判断到第n个丑数，返回第n个丑数的值。这种方法由于充斥了大量的重复计算，效率很低，因此会导致TLE（Time Limit Exceeded）的结果。

Java代码如下：

/**
 * 功能说明：LeetCode 263 - Ugly Number
 * 开发人员：Tsybius2014
 * 开发时间：2015年8月23日
 */
public class Solution {
    
    /**
     * 求第N个丑数
     * @param n
     * @return 第N个丑数
     */
    public int nthUglyNumber(int n) {
    
        if (n <= 1) {
            return 1;
        }

        int counter = 0;
        for (int i = 1; ; i++) {
            
            if (isUgly(i)) {
                counter++;
                if (counter == n) {
                    return i;
                }
            } 
        }
    }
    
    /**
     * 判断数字是否为丑数
     * @param num 被判断数字
     * @return true：丑数，false：非丑数
     */
    public boolean isUgly(int num) {
        
        if (num <= 0) {
            return false;
        }
        
        while (num % 2 == 0) num /= 2;
        while (num % 3 == 0) num /= 3;
        while (num % 5 == 0) num /= 5;
        
        if (num == 1) {
            return true;
        } else {
            return false;
        }
    }
}

6、解题方法

关于如果更加快速有效地找出第n个丑数的问题，网上已经有很多解题方法和大牛的博客可以参考，这里只是简要说明我用的方法：

  1. 申请一个长度为n的数组uglyNumbers，用于从小到大顺序存储n个丑数，数组中的首项为1，即第一个丑数为1

  2. 设置三个变量idx2、idx3、idx5存储下标，初始值都为0

  3. 找出数组uglyNumbers[idx2]*2、uglyNumbers[idx3]*3、uglyNumbers[idx5]*5的最小值，最小值即为下一个丑数，同时更新最小值对应的下标，如果多个数字同时为最小值，则它们的下标都要更新

  4. 找到第n个丑数时，循环结束

一段实现此方法的Java代码如下：

/**
 * 功能说明：LeetCode 264 - Ugly Number II
 * 开发人员：Tsybius2014
 * 开发时间：2015年8月23日
 */
public class Solution {
    
    /**
     * 求第N个丑数
     * @param n
     * @return 第N个丑数
     */
    public int nthUglyNumber(int n) {
        
        int[] uglyNumbers = new int[n];
        uglyNumbers[0] = 1;
//      System.out.println("uglyNumbers[0]:1");
        
        int idx2 = 0;
        int idx3 = 0;
        int idx5 = 0;

        int counter = 1;
        while (counter < n) {

//          System.out.println("-----------");
//          System.out.println("idx2:" + idx2 + ";ugly[idx2]:" + uglyNumbers[idx2]);
//          System.out.println("idx3:" + idx3 + ";ugly[idx3]:" + uglyNumbers[idx3]);
//          System.out.println("idx5:" + idx5 + ";ugly[idx5]:" + uglyNumbers[idx5]);
//          System.out.println("idx2:" + idx2 + ";idx3:" + idx3 + ";idx5:" + idx5);
            
            int min = minOf(
                uglyNumbers[idx2] * 2, 
                uglyNumbers[idx3] * 3, 
                uglyNumbers[idx5] * 5);
            
            if (min == uglyNumbers[idx2] * 2) {
//              System.out.println("min==ugly[idx2]*2:" + uglyNumbers[idx2] * 2);
//              System.out.println("idx2:" + idx2 + "→" + (idx2 + 1));
                idx2++;
            }

            if (min == uglyNumbers[idx3] * 3) {
//              System.out.println("min==ugly[idx3]*3:" + uglyNumbers[idx3] * 3);
//              System.out.println("idx3:" + idx3 + "→" + (idx3 + 1));
                idx3++;
            }

            if (min == uglyNumbers[idx5] * 5) {
//              System.out.println("min==ugly[idx5]*5:" + uglyNumbers[idx5] * 5);
//              System.out.println("idx5:" + idx5 + "→" + (idx5 + 1));
                idx5++;
            }
            
            uglyNumbers[counter] = min;
//          System.out.println("uglyNumbers[" + counter + "]:" + min);
            counter++;
        }

//      System.out.println("-----------");
//      System.out.println("return:" + uglyNumbers[n - 1]);
        
        return uglyNumbers[n - 1];
    }
    
    /**
     * 求三个数字中最小的数字
     * @param a 数字a
     * @param b 数字b
     * @param c 数字c
     * @return a、b、c中最小的数字
     */
    private int minOf(int a, int b, int c) {
        int temp = a < b ? a : b;
        return temp < c ? temp : c; 
    }
}

为了方便理解这段代码，我在这段代码里加入了System.out.println函数用于将结果输出到控制台。解除这些注释行，并指定输入的n为15，执行函数时输出到控制台的结果如下：

uglyNumbers[0]:1
-----------
idx2:0;ugly[idx2]:1
idx3:0;ugly[idx3]:1
idx5:0;ugly[idx5]:1
idx2:0;idx3:0;idx5:0
min==ugly[idx2]*2:2
idx2:0→1
uglyNumbers[1]:2
-----------
idx2:1;ugly[idx2]:2
idx3:0;ugly[idx3]:1
idx5:0;ugly[idx5]:1
idx2:1;idx3:0;idx5:0
min==ugly[idx3]*3:3
idx3:0→1
uglyNumbers[2]:3
-----------
idx2:1;ugly[idx2]:2
idx3:1;ugly[idx3]:2
idx5:0;ugly[idx5]:1
idx2:1;idx3:1;idx5:0
min==ugly[idx2]*2:4
idx2:1→2
uglyNumbers[3]:4
-----------
idx2:2;ugly[idx2]:3
idx3:1;ugly[idx3]:2
idx5:0;ugly[idx5]:1
idx2:2;idx3:1;idx5:0
min==ugly[idx5]*5:5
idx5:0→1
uglyNumbers[4]:5
-----------
idx2:2;ugly[idx2]:3
idx3:1;ugly[idx3]:2
idx5:1;ugly[idx5]:2
idx2:2;idx3:1;idx5:1
min==ugly[idx2]*2:6
idx2:2→3
min==ugly[idx3]*3:6
idx3:1→2
uglyNumbers[5]:6
-----------
idx2:3;ugly[idx2]:4
idx3:2;ugly[idx3]:3
idx5:1;ugly[idx5]:2
idx2:3;idx3:2;idx5:1
min==ugly[idx2]*2:8
idx2:3→4
uglyNumbers[6]:8
-----------
idx2:4;ugly[idx2]:5
idx3:2;ugly[idx3]:3
idx5:1;ugly[idx5]:2
idx2:4;idx3:2;idx5:1
min==ugly[idx3]*3:9
idx3:2→3
uglyNumbers[7]:9
-----------
idx2:4;ugly[idx2]:5
idx3:3;ugly[idx3]:4
idx5:1;ugly[idx5]:2
idx2:4;idx3:3;idx5:1
min==ugly[idx2]*2:10
idx2:4→5
min==ugly[idx5]*5:10
idx5:1→2
uglyNumbers[8]:10
-----------
idx2:5;ugly[idx2]:6
idx3:3;ugly[idx3]:4
idx5:2;ugly[idx5]:3
idx2:5;idx3:3;idx5:2
min==ugly[idx2]*2:12
idx2:5→6
min==ugly[idx3]*3:12
idx3:3→4
uglyNumbers[9]:12
-----------
idx2:6;ugly[idx2]:8
idx3:4;ugly[idx3]:5
idx5:2;ugly[idx5]:3
idx2:6;idx3:4;idx5:2
min==ugly[idx3]*3:15
idx3:4→5
min==ugly[idx5]*5:15
idx5:2→3
uglyNumbers[10]:15
-----------
idx2:6;ugly[idx2]:8
idx3:5;ugly[idx3]:6
idx5:3;ugly[idx5]:4
idx2:6;idx3:5;idx5:3
min==ugly[idx2]*2:16
idx2:6→7
uglyNumbers[11]:16
-----------
idx2:7;ugly[idx2]:9
idx3:5;ugly[idx3]:6
idx5:3;ugly[idx5]:4
idx2:7;idx3:5;idx5:3
min==ugly[idx2]*2:18
idx2:7→8
min==ugly[idx3]*3:18
idx3:5→6
uglyNumbers[12]:18
-----------
idx2:8;ugly[idx2]:10
idx3:6;ugly[idx3]:8
idx5:3;ugly[idx5]:4
idx2:8;idx3:6;idx5:3
min==ugly[idx2]*2:20
idx2:8→9
min==ugly[idx5]*5:20
idx5:3→4
uglyNumbers[13]:20
-----------
idx2:9;ugly[idx2]:12
idx3:6;ugly[idx3]:8
idx5:4;ugly[idx5]:5
idx2:9;idx3:6;idx5:4
min==ugly[idx2]*2:24
idx2:9→10
min==ugly[idx3]*3:24
idx3:6→7
uglyNumbers[14]:24
-----------
return:24

END

转载于:https://my.oschina.net/Tsybius2014/blog/495962

chenzai1946
关注
leetcodepalindrom-LeetCode---Palindrom-Number:LeetCode---回文数
07-01
在LeetCode---Palindrom-Number-master这个压缩包中，很可能包含了这个问题的多个解法，包括但不限于Python、Java、C++等常见编程语言的实现。这些代码可以作为学习和参考的资源，帮助你更好地理解和掌握回文数的...
第n个丑数【动态规划、堆、二分】
peko1的博客
04-18 683
题目是丑数 丑数是能被2，3，5整除的数，我们可以从1开始构造丑数，某个数a是丑数，那么2a、3a、5a都是丑数 方法一：使用堆实现：使用最小堆，初始堆为空，将最小的丑数1加入堆，每次取出堆中的最小的元素x，并将2x、3x、5x加入堆中。但是可能会出现重复的情况，因此我们多建立一个set集合来去重，只有在set中没有出现的元素才加入到堆中。 代码如下： int nthUglyNumber(int n) { vector<int>f={2,3,5}; unordered_se
经典面试题目——找到第n个丑数(参考《剑指offer(第二版)》面试题49)
weixin_30493321的博客
05-10 248
一.题目大意 　　给你一个数n，要求返回第n个丑数。其中，丑数的定义如下： 　　丑数是指只包含因子2、3和5的数。(数字1也是丑数，不过是个特例)引用《剑指offer》上的话来说，对于一个数M，如果M能被2整除，就连续除以2；若果能被3整除，就连续除以3；如果能被5整除，就连续除以5。如果最终的结果是1的话，那么M就是丑数，否则M不是丑数。以下是判断一个数是否为丑数的代码： bool I...
百道经典算法题——丑数
qq_24263553的博客
03-09 686
寻找第N个丑数 我们把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。 示例： 输入: n = 10 输出: 12 解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。 说明： 1、1 是丑数。 2、n 不超...
计算第 N 个丑数
菜鸟日常
07-14 362
概述 我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。 示例: 输入: n = 10 输出: 12 解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。 说明: 1 是丑数。 n 不超过1690。 https://leetcode-cn.com/problems/chou-shu-lcof/ 思路 核心思路：计算后面的丑数，就是把前面已计算出的丑数 x2，x3，x5，然后取最小值得到。 假设存在 3
求第n个丑数
HanSion.Z
09-16 5457
一.求第N个丑数 题目：我们把只包含因子2、3、5的数称作丑数(UglyNumber)。假设现在求从小到大排序的第1500个丑数。例如，6、8都是丑数，但是14不是丑数，因为它还包括素因子7。 解题思路一：暴力枚举法。 1.首先，我们应该了解什么是因子。所谓的数m是数n的因子，是指数n可以被数m整除，既n%m=0。 2.要判断一个数是不是为丑数。就要判断这个数除了能被2、3、5整除，是否可...
leetcode104-qijin-tech-leetcode:qijin-tech-leetcode
06-30
LeetCode2. 链表题。逻辑难度不大，细节很多。 LeetCode771. 方法一：用现成的HashMap的contains方法。 时间复杂度O(N)，空间复杂度O(N)。应该有更好的方法 TODO LeetCode226. 典型的递归问题。 LeetCode617. 递归是...
gasstationleetcode-leetcode:https://leetcode-cn.com
06-30
加油站 leetcode leetcode Java 中的 Leetcode 解决方案 基础 （简单的） ...【278第一个坏版】 [35 搜索插入位置] [33 在旋转排序数组中搜索] [81 在旋转排序数组中搜索 II] [153 在旋转排序数组中找到最小
leetcode中国-Make-Dir-For-Leetcode:Make-Dir-For-Leetcode
06-29
leetcode中国Make-Dir-For-Leetcode 演示 什么 这个脚本会为 LeetCode 创建一个文件夹，在每个子文件夹中会有一个名为README.md的文件，这个文件的内容就是 LeetCode 对应的问题内容。 WHO 如果你想使用 LeetCode 来...
离线和leetcode-skygragon-leetcode-cli:skygragon-leetcode-cli
07-06
leetcode-cli 一个享受leetcode的cli工具！ 非常感谢 leetcode.com，一个非常棒的网站！ ⦙⦙⦙⦙⦙⦙ 解决问题的一种方式。 本地问题，因此您可以轻松导航和离线思考。 在CLI 中做所有事情，甚至没有人知道你在做 ...
【动态规划】49题-丑数
...
02-01 279
1 题目描述 我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。 示例： 输入: n = 10 输出: 12 解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。 说明： 1 是丑数。 n 不超过1690。 2 解题思路 动态规划 解题思路： 丑数的递推性质：丑数只包含因子2，3，5，因此有“丑数=某较小丑数×某因子丑数=某较小丑数\times某因子丑数=某较小丑数×某因子”（例如：10=5×210=5
动态规划法解第n个丑数问题
douyh的专栏
01-24 356
丑数是唯一素数为2、3或5的数。序列1、2、3、4、5、6、8、9、10、12、15…显示前11个丑数。按照惯例，其中包括1。 给定数字n，任务是查找第n个丑数。 输入：n = 7 输出8 输入：n = 10 输出：12 输入：n = 15 输出：24 输入：n = 150 输出：5832 方法1（简单） 对所有正整数循环，直到一个丑陋的数字小于n（如果一个整数丑陋而不是递增的丑陋数字计数）。 要检查数字是否丑陋，请将该数字除以2、3和5的最大可除幂。如果数字变为1，则它是丑陋的数字，否则不是。 例
计算第N个丑数(Ugly Number)
xiaofeng
08-01 981
题目描述 包含质因子2、3和5的数称作丑数。 例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。 按从小到大的顺序求第N个丑数 题目分析： 质因子包含2、3、5三个中任意一个或者多个；而且题目明确给出1为最小的丑数；因此可以从1开始，对后面的数依次乘以2、3、5. 比如一个数组，最开始只有一个元素1，建立三个索引p2、p3、p5，分别记录乘2、乘3、乘5的位置，然后将1分别乘以2、3、5，取其中最小的一个数，作为丑数填入数组中，依次循环，直至取到第N个数。 这三个索引是关
算法：第n个丑数-java
xxxxssss12的博客
07-29 369
丑数定义 1是丑数 只包含质因子2，3和5的数称作丑数。如8，6，15 算法思路 一个丑数（除1外）是排在它前边的某个丑数乘以2或者乘以3或者乘以5得到的，那么我们只要在当前得到的丑数集合中找到比当前集合中最大丑数刚刚好大的丑数即可，因为我们要保持有序，才好找到第N个丑数，现在难点是怎么在O（1）时间内就找到一个丑数，使得它乘以2或者乘以3或者乘以5刚刚好大于当前最大丑数呢？ 我们设置三个游标，一个表示所指丑数乘以2是下一个可能加入到丑数集合中的丑数，一个表示所指丑数乘以3是下一个可能加入到丑数集合中的
牛客_找寻第n个丑数
zhangvalue的博客
02-28 233
题目描述 把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。 分析： 一个丑数的质因子只有2,3,5，那么丑数p = 2 ^ x * 3 ^ y * 5 ^ z，换句话说一个丑数一定由另一个丑数乘以2或者乘以3或者乘以5得到，那么我们从1开始乘以2,3,5，就得...
找出第n个丑数
qq_39543837的博客
08-23 1587
问题描述： 设计一个算法，找出只含素因子2，3，5 的第 n 小的数。 符合条件的数如：1, 2, 3, 4, 5, 6, 8, 9, 10, 12… 样例 如果n = 9， 返回 10 挑战 要求时间复杂度为O(nlogn)或者O(n) 注意事项 我们可以认为1也是一个丑数 方法一：可以遍历每一个数，当它是丑数时，计数加1，直到它是第n个丑数。 而丑数的判断是：2^i *3^...
Python实现获取第n个丑数
小马王
02-16 1766
丑数：只包含质因子2，3和5的数称作丑数（Ugly Number），1为最小丑数 核心思想：新丑数一定是由已得丑数乘丑数因子得到的，要得到有序丑数列表，在已得丑数列表基础上依次追加未得最小丑数即可，进而可得第n个丑数 完整方法： import numpy as np from datetime import datetime # 获取第n个丑数，n从1开始 # 返回：目标丑数，丑数列表...
Python | 动态规划解决“返回第n个丑数”
算法与编程之美
04-28 1029
本文首发于微信公众号："算法与编程之美"，欢迎关注，及时了解更多此系列文章。问题描述给你一个整数n，请你找出并返回第n个丑数。丑数就是只包含质因数2、3和...
算法：求第n个丑数
Ricardo_lun的博客
03-05 661
求第n个丑数 我们把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。 例： 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。 思路：将前面求得的丑数记录下来，后面的丑数就是前面的丑数*2，*3，*5，已知前面k-1个丑数，采取用三个指针的方法p2,p3,p5，这里p2指向的数字下一次永远乘2，p3指向的数字下...
LeetCode：计算各位数字都不同的数字个数
例如，对于第一个位置有10个选择，第二个位置有9个选择（因为不能与第一个位置相同），依此类推。因此，对于n位数字，总的可能性可以表示为10 * 9 * ... * (11-n)。这种方法比回溯法更高效，因为它不需要实际生成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值