华为机试—寻找丑数(由浅入深优化至20ms)

题目描述:

把只包含因子2、3和5的数称作丑数(Ugly Number)。例如6、8都是丑数,但14不是,因为它包含因子7。

习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

输入:

输入包括一个整数N(1<=N<=1500)。

输出:

可能有多组测试数据,对于每组数据,

输出第N个丑数。

样例输入:
3
样例输出:
3

所谓一个数m是另一个数n的因子,是指n能被m整除,也就是n
% m == 0。根据丑数的定义,丑数只能被2、3和5整除。也就是说如果一个数如果它能被2整除,我们把它连续除以2;如果能被3整除,就连续除以3;如果能被5整除,就除以连续5。如果最后我们得到的是1,那么这个数就是丑数,否则不是。

基于前面的分析,我们可以写出如下的函数来判断一个数是不是丑数:

bool IsUgly(int number)
{
	while(number % 2 == 0)
        number /= 2;
    while(number % 3 == 0)
        number /= 3;
    while(number % 5 == 0)
        number /= 5;
    return (number == 1) ? true : false;
}

接下来,我们只需要按顺序判断每一个整数是不是丑数,即:

int GetUglyNumber(int index)
{
	if(index <= 0)
        return 0;
    int number = 0;
    int uglyFound = 0;

	while(uglyFound < index)
    {
		++number;
        if(IsUgly(number))
			++uglyFound;

	}
	return number;
}

我们只需要在函数GetUglyNumber中传入参数1500,就能得到第1500个丑数。该算法非常直观,代码也非常简洁,但最大的问题我们每个整数都需要计算。即使一个数字不是丑数,我们还是需要对它做求余数和除法操作。因此该算法的时间效率不是很高。

接下来我们换一种思路来分析这个问题,试图只计算丑数,而不在非丑数的整数上花费时间。根据丑数的定义,丑数应该是另一个丑数乘以2、3或者5的结果(1除外)。因此我们可以创建一个数组,里面的数字是排好序的丑数。里面的每一个丑数是前面的丑数乘以2、3或者5得到的。

这种思路的关键在于怎样确保数组里面的丑数是排好序的。我们假设数组中已经有若干个丑数,排好序后存在数组中。我们把现有的最大丑数记做M。现在我们来生成下一个丑数,该丑数肯定是前面某一个丑数乘以2、3或者5的结果。我们首先考虑把已有的每个丑数乘以2。在乘以2的时候,能得到若干个结果小于或等于M的。由于我们是按照顺序生成的,小于或者等于M肯定已经在数组中了,我们不需再次考虑;我们还会得到若干个大于M的结果,但我们只需要第一个大于M的结果,因为我们希望丑数是按从小到大顺序生成的,其他更大的结果我们以后再说。我们把得到的第一个乘以2后大于M的结果,记为M2。同样我们把已有的每一个丑数乘以3和5,能得到第一个大于M的结果M3和M5。那么下一个丑数应该是M2、M3和M5三个数的最小者。

前面我们分析的时候,提到把已有的每个丑数分别都乘以2、3和5,事实上是不需要的,因为已有的丑数是按顺序存在数组中的。对乘以2而言,肯定存在某一个丑数T2,排在它之前的每一个丑数乘以2得到的结果都会小于已有最大的丑数,在它之后的每一个丑数乘以2得到的结果都会太大。我们只需要记下这个丑数的位置,同时每次生成新的丑数的时候,去更新这个T2。对乘以3和5而言,存在着同样的T3和T5。

有了这些分析,我们不难写出如下的代码:

int pUglyNumbers[1501];
int GetUglyNumber(int index)
{
	if(index <= 0)
        return 0;

    pUglyNumbers[0] = 1;

    int nextUglyIndex = 1;

    int index2 = 0;
    int index3 = 0;
    int index5 = 0;

    while(nextUglyIndex < index)
	{
		int min = Min(pUglyNumbers[index2] * 2, pUglyNumbers[index3] * 3, pUglyNumbers[index5] * 5);
        pUglyNumbers[nextUglyIndex] = min;

		while(pUglyNumbers[index2] * 2 <= pUglyNumbers[nextUglyIndex])
			++index2;
        while(pUglyNumbers[index3] * 3 <= pUglyNumbers[nextUglyIndex])
            ++index3;
        while(pUglyNumbers[index5] * 5 <= pUglyNumbers[nextUglyIndex])
            ++index5;

		++nextUglyIndex;
    }

    int ugly = pUglyNumbers[nextUglyIndex - 1];

    return ugly;
}

和第一种思路相比,这种算法不需要在非丑数的整数上做任何计算,因此时间复杂度要低很多。当然我们也要指出,第二种算法由于要保存已经生成的丑数,因此需要一个数组,从而需要额外的内存。第一种算法是没有这样的内存开销的。

完整的代码如下:

优化前:

#include <stdio.h>

bool IsUgly(int number)
{
	while(number % 2 == 0)
        number /= 2;
    while(number % 3 == 0)
        number /= 3;
    while(number % 5 == 0)
        number /= 5;
    return (number == 1) ? true : false;
}

int GetUglyNumbe(int index)
{
	if(index <= 0)
        return 0;
    int number = 0;
    int uglyFound = 0;

	while(uglyFound < index)
    {
		++number;
        if(IsUgly(number))
			++uglyFound;

	}
	return number;
}

void main()
{
	int n;
	while(~scanf("%d",&n))
		printf("%d\n",GetUglyNumbe(n));

	printf("\n");
}

优化后:

#include <stdio.h>

int pUglyNumbers[1501];

int Min(int number1, int number2, int number3)
{
	int min = (number1 < number2) ? number1 : number2;
    min = (min < number3) ? min : number3;
    return min;
}

int GetUglyNumber(int index)
{
	if(index <= 0)
        return 0;

    pUglyNumbers[0] = 1;

    int nextUglyIndex = 1;

    int index2 = 0;
    int index3 = 0;
    int index5 = 0;

    while(nextUglyIndex < index)
	{
		int min = Min(pUglyNumbers[index2] * 2, pUglyNumbers[index3] * 3, pUglyNumbers[index5] * 5);
        pUglyNumbers[nextUglyIndex] = min;

		while(pUglyNumbers[index2] * 2 <= pUglyNumbers[nextUglyIndex])
			++index2;
        while(pUglyNumbers[index3] * 3 <= pUglyNumbers[nextUglyIndex])
            ++index3;
        while(pUglyNumbers[index5] * 5 <= pUglyNumbers[nextUglyIndex])
            ++index5;

		++nextUglyIndex;
    }

    int ugly = pUglyNumbers[nextUglyIndex - 1];

    return ugly;
}

int main()
{
	int n;
	while(~scanf("%d",&n))
		printf("%d\n",GetUglyNumber(n));

	return 0;

}

测试结果:

时间: 2024-10-28 18:26:12

华为机试—寻找丑数(由浅入深优化至20ms)的相关文章

华为机试—寻找丑数 &amp;&amp; 九度OJ 1214

题目1214:丑数 时间限制:1 秒 内存限制:32 兆 特殊判题:否 提交:1733 解决:771 题目描述: 把只包含因子2.3和5的数称作丑数(Ugly Number).例如6.8都是丑数,但14不是,因为它包含因子7. 习惯上我们把1当做是第一个丑数.求按从小到大的顺序的第N个丑数. 输入: 输入包括一个整数N(1<=N<=1500). 输出: 可能有多组测试数据,对于每组数据, 输出第N个丑数. 样例输入: 3 样例输出: 3 #include<iostream> #in

华为机试-自守数

题目描述自守数是指一个数的平方的尾数等于该数自身的自然数.例如:25^2 = 625,76^2 = 5776,9376^2 = 87909376.请求出n以内的自守数的个数 接口说明 /*功能: 求出n以内的自守数的个数 输入参数:int n返回值:n以内自守数的数量.*/ public static int CalcAutomorphicNumbers( int n){/*在这里实现功能*/return 0;} 输入描述:int型整数输出描述:n以内自守数的数量.示例1输入 2000输出 8

华为机试—回文数判断

判断一个整型数是否为"回文数",如1221,232,5. #include <iostream> using namespace std; void isHuiwen(int number) { int n = 0;//余数. int m = number; while(m != 0) { n = n*10 + m %10; //number的最低位变为n的最高位 m = m /10; } if(n==number) cout << "yes"

2015华为机试——高次方数的尾数

题目描述: 求解M的N次方的最后三位数(M,N均大于10). 接口说明 原型: int GetLast3DigitsOfMN(int M, int N); 输入参数: int M:M > 10 int N:N > 10 返回值: M的N次方的最后三位数 解题思路: 思路一:先求M的N次方,然后M^N%1000求最后三位数,但是M的N次方很有可能会溢出,导致输出结果异常或错误. 思路二:思路一不行的话,我们得找到他对应的等效方法,M每乘M就对1000求余,其最后三位数是等效的. 代码如下: pu

2014华为机试西安地区B组试题

2014华为机试西安地区B组试题 题目一.亮着点灯的盏数 一条长廊里依次装有n(1≤n≤65535)盏电灯,从头到尾编号1.2.3.-n-1.n.每盏电灯由一个拉线开关控制.开始,电灯全部关着. 有n个学生从长廊穿过.第一个学生把号码凡是1的倍数的电灯的开关拉一下:接着第二个学生把号码凡是2的倍数的电灯的开关拉一下:接着第三个学生把号码凡是3的倍数的电灯的开关拉一下:如此继续下去,最后第n个学生把号码凡是n的倍数的电灯的开关拉一下.n个学生按此规定走完后,长廊里电灯有几盏亮着. 注:电灯数和学生

华为机试(2)

简单题   题目描述  输入一个字符串,统计其出现频率最高的字符,并输出.若存在两个字符出现频率相同,则输出字典序较小的那一个   输入描述  :一个字符串,保证没有空格,以回车符结束,字符串长度<=20   输出描述  :一个字符   输入样例 :aabbaabb  输出样例  :a  解题思路:做一个频率数组来统计所有字符的出现频率,机试时候不会有汉字输入,因此只考虑输入是ASCII编码的情况. #include<string> #include<iostream> us

华为机试—介绍、剖析、建议

一.华为机试介绍 1.大致介绍 时间:120分钟 环境:Visual Studio(去年是vs2005).Visual C++.VC 6.0.Eclipse(Java) 题量:共3题 初级题--60分--3组测试数据 中级题--100分--5组测试数据 高级题--160分--8组测试数据 注:初级题和中级题为必答题,高级题为附加题. 提交次数:每题最多5次 评判方式:按通过测试数据组数给分,每通过一组得20分 2.考试说明 这里有一个老版的机试考试说明,供大家参考: C/C++,JAVA机试流程

华为机试(3)

简单题   题目描述   输入一个数字,将其倒序输出,并输出其各个位上的乘积   输入描述  : 一个正整数,保证在int范围内   输出描述  : 两个数字,用空格隔开,第一个数字为其倒序的值,第二个数字是各个位上的乘积  输入样例  :134   输出样例  :431 12  解题思路:删繁就简,直接当字符串读入,处理就简单多了.  PS:此处不用纠结于题意,没有特别强调是按照一个数的格式输出,因此可以有前导0 void main() { int d; cin>>d; ostringstr

华为机试(5)

中级题  题目描述  你有一个容量为100的箩筐,给你30个物品,每个物品的体积已知问:最多能装多少个物品进箩筐  输入描述  :一行30个正整数,用空格隔开,表示每个物品的体积  输出描述  :一个数字,为最多能装下的物品数 输入样例(此处用3个物品作为样例,实际读入为30个)  :5 59 100  输出样例  :2 解题思路:利用性价比对所有物品进行排序,优先装性价比高的,在此题中,性价比就是物品的体积 #include<algorithm>//sort函数 #include<io