时间空间效率的平衡:丑数

把只包含因子2、3和5的数称作丑数(Ugly Number)。例如6、8都是丑数,但14不是,因为它包含因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

public class Solution {
    final int d[] = { 2, 3, 5 };

    public int GetUglyNumber_Solution(int index) {
        if (index == 0)
            return 0;
        int a[] = new int[index];
        a[0] = 1;
        int p[] = new int[] { 0, 0, 0 };
        int num[] = new int[] { 2, 3, 5 };
        int cur = 1;

        while (cur < index) {
            int m = finMin(num[0], num[1], num[2]);
            if (a[cur - 1] < num[m])
                a[cur++] = num[m];
            p[m] += 1;
            num[m] = a[p[m]] * d[m];
        }
        return a[index - 1];
    }

    private int finMin(int num2, int num3, int num5) {
        int min = Math.min(num2, Math.min(num3, num5));
        return min == num2 ? 0 : min == num3 ? 1 : 2;
    }
}
时间: 2024-08-09 00:16:18

时间空间效率的平衡:丑数的相关文章

时间空间效率的平衡:数组中的逆序对

在数组中的两个数字,如果前面一个数字大于后面的数字,则这两个数字组成一个逆序对.输入一个数组,求出这个数组中的逆序对的总数P.并将P对1000000007取模的结果输出. 即输出P%1000000007 输入描述: 题目保证输入的数组中没有的相同的数字 数据范围: 对于%50的数据,size<=10^4 对于%75的数据,size<=10^5 对于%100的数据,size<=2*10^5 输入例子: 1,2,3,4,5,6,7,0 输出例子: 7

时间空间效率的平衡:第一个只出现一次的字符位置

在一个字符串(1<=字符串长度<=10000,全部由大小写字母组成)中找到第一个只出现一次的字符,并返回它的位置 import java.util.LinkedHashMap; public class Solution { public int FirstNotRepeatingChar(String str) { LinkedHashMap<Character, Integer> map = new LinkedHashMap<Character, Integer>

50-02 字符流中第一个不重复的字符( 时间空间效率的平衡)

题目描述: 请实现一个函数用来找出字符流中第一个只出现一次的字符.例如,当从字符流中只读出前两个字符"go"时,第一个只出现一次的字符是"g".当从该字符流中读出前六个字符“google"时,第一个只出现一次的字符是"l". 输出描述: 如果当前字符流没有存在出现一次的字符,返回#字符.   测试用例: 1)功能测试(读入一个字符,读入多个字符,读入的所有字符都是唯一的,读入的所有字符都是重复出现的) 2)特殊输入测试(读入0个字符时)

剑指offer 36.时间空间效率的平衡 两个链表的第一个公共结点

题目描述 输入两个链表,找出它们的第一个公共结点. 解题思路 如果存在共同节点的话,那么从该节点,两个链表之后的元素都是相同的. 也就是说两个链表从尾部往前到某个点,节点都是一样的. 我们可以用两个栈分别来装这两条链表.一个一个比较出来的值. 找到第一个相同的节点. 代码如下 public class FindFirstCommonNode { public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) { if (

第 n 个丑数

自己想了两天都没思路啊啊啊啊啊我真是太笨了.看了他的 tag,说是用到了动态规划,于是特意看了算法导论里动态规划的部分.然而只是说了其思想,第一步构建合理的数据结构,第二部以递归的形式求解.可见水无常形,动态规划并不是单纯的公式就可以解决的.那么具体如何处理呢? 第一是,什么时候会用到动态规划,就是这样一种情况:后面的结果来自于前面的结果,而前面的结果又已经被求解后存储.前者意味着它的递归结构,后者有种空间换时间的意味. 明确这个就进入第二个问题,丑数是什么? 除了 1 之外,由且只由 2 3

34 - 丑数

题目描述:http://ac.jobdu.com/problem.php?pid=1214 把只包含因子2.3和5的数称作丑数(Ugly Number).例如6.8都是丑数,但14不是,因为它包含因子7. 习惯上我们把1当做是第一个丑数.求按从小到大的顺序的第N个丑数. 解析: 丑数的定义应该为:质因子只含有2.3.5的数 .1 默认是一个丑数. e.g. 8 = 2*2*2; 18 = 2*3*3 都是丑数 直观想法是: 判断一个数是否是丑数,如果它能被2整除,则一直除以2,同理能被3,5整除

剑指offer-第5章优化时间和空间效率(丑数)

题目:我们把只包含因子2,3,5的数叫做丑数.寻找第1500个丑数.通常把1当成第一个丑数. 思路1:第一步判断是否为丑数:丑数是只包含2,3,5的数,因此一定可以被2,3,5整除.通过求余数是否为零做为判断条件,通过除以来减小整个数的值,知道整个数为1.返回true. 第二步找到第N个丑数的值,这一种做法的缺点是,不是丑数的数也要求余数除数的运算,因此耗时.因此我们提出一种以空间换时间的方法(谁让如今硬件更新的快呢).如2思路. 思路2:我采用一个数组按照从小到大的顺序存放丑数.数组中最后一个

插入排序的优化【不靠谱地讲可以优化到O(nlogn)】 USACO 丑数

首先我们先介绍一下普通的插排,就是我们现在一般写的那种,效率是O(n^2)的. 普通的插排基于的思想就是找位置,然后插入进去,其他在它后面的元素全部后移,下面是普通插排的代码: 1 #include<iostream> 2 #include<fstream> 3 #include<stdio.h> 4 using namespace std; 5 int a[200000]; 6 int p[200000]; 7 8 int main(){ 9 ios::sync_wi

c语言:把只含因子2、3和5的数称为丑数,求按从小到大的顺序的第1500个丑数(两种方法比较)

把只含因子2.3和5的数称为丑数,求按从小到大的顺序的第1500个丑数.例如6.8都是丑数,但14不是,因为它包含因子7.习惯上把1当作第1个丑数. 算法1:逐个判断每个整数是不是丑数的解法,直观但不够高效 #include<stdio.h> int ugly(int number) { while (number % 2 == 0) { number /= 2; } while (number % 3 == 0) { number /= 3; } while (number % 5 == 0