剑指offer 丑数（C++）3种方法（一层一层的剥开它的心）

题目描述

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

解题思路

我首先想到的是逆向思维方法：递归方法，写出来后是正确的，由于运行时间比较长，OJ报错；其次使用循环，依旧是运行时间过长，OJ报错。如果给出的index比较大的话，这两种方法在VS2013上面的确耗费了很长时间（下述）。

只能用正向思维的方法来解答此题了（下述）。

什么叫丑数，有且仅有公因子$2、3$或$5$的数称为丑数。也就是任何一个丑数都是由$2、3$或$5$的任意数值和该数值的任意次幂后相乘得来，即 $p=2^x\times 3^y\times 5^z$ 除此之外，不能称为丑数。

首先的想法是定义一个判断是否是丑数的bool函数，即给定一个数，如果是丑数返回true，否则返回false；在此基础上，给定函数中设置循环，注意判断每个数字是否是丑数，返回第N个丑数为止，但这种方法消耗的时间过长，系统没有通过，下面展示具体递归和非递归的代码。

第二种思路：最小的丑数是$1$，则$2、3、5$便是接下来的丑数，它们按照一定的数值乘积求和，逐步迭代，最终按照有由小到大依次排列，就可以得到从小到大的丑数（下述）。

代码实现

1、递归方法

一个数$n$，当$n=1$时，一定是丑数，当$n$能被$2$整除的时，返回 递归$n/2$，只要能被$2，3，5$整除，就会一直递归将$n$变成$1$，这个数为丑数；但是一旦出现递归时，$n=7$这样的情况，说明这个数不是丑数。

这种递归的方法就是将这个数一点一点的进行解剖，就像洋葱一样一层一层的剥开它的心，你会发现，你会讶异，就会发现它最深处的秘密，每次剥掉$2$或$3$或$5$，直到为$1$为止，说明这颗洋葱全都是有$2、3、5$组成的，说明是丑数。

bool IsUglyNumber(int n)
{
	if (n == 1)
	{
		return true;
	}
	if (n % 2 == 0)
	{
		return IsUglyNumber(n / 2);
	}
	if (n % 3 == 0)
	{
		return IsUglyNumber(n / 3);
	}
	if (n % 5 == 0)
	{
		return IsUglyNumber(n / 5);
	}
	return false;
}

int GetUglyNumber_Solution(int index) {
	int count = 0;
	for (int i = 1; i <= INT_MAX; i++)
	{
		if (IsUglyNumber(i))
		{
			count++;
			if (count == index)
				return i;
		}
	}
}

2、非递归方法

和递归的思想是一样的，每次循环，最后循环结束后，判断是否为$1$即可。

bool IsUglyNumber(int n)
{
	if (n == 1)
	{
		return true;
	}
	while (n > 1)
	{
		if (n % 2 == 0)
		{
			n /= 2;
			continue;
		}
		else if (n % 3 == 0)
		{
			n /= 3;
			continue;
		}
		else if (n % 5 == 0)
		{
			n /= 5;
			continue;
		}
		else
		{
			break;
		}
	}
	if (n == 1)
	{
		return true;
	}
	return false;
}

int GetUglyNumber_Solution(int index) {
	int count = 0;
	for (int i = 1; i <= INT_MAX; i++)
	{
		if (IsUglyNumber(i))
		{
			count++;
			if (count == index)
				return i;
		}
	}
}

3、递推方法

首先从丑数的定义我们知道，一个丑数的因子只有$2,3,5$，那么丑数$p=2^x\times 3^y\times 5^z$，换句话说一个丑数一定由另一个丑数乘以$2$或者乘以$3$或者乘以$5$得到，那么我们从$1$开始乘以$2,3,5$，就得到$2,3,5$三个丑数，在从这三个丑数出发乘以$2,3,5$就得到$4，6,10,6,9,15,10,15,25$九个丑数，我们发现这种方法得到重复的丑数，而且我们题目要求第$N$个丑数，这样的方法得到的丑数也是无序的。那么我们可以维护三个队列：
（1）
丑数数组：$1$
乘以$2$的队列：$2$
乘以$3$的队列：$3$
乘以$5$的队列：$5$

选择三个队列头最小的数$2$加入丑数数组，同时将该最小的数乘以$2,3,5$放入三个队列；

（2）
丑数数组：$1,2$
乘以$2$的队列：$4$
乘以$3$的队列：$3，6$
乘以$5$的队列：$5，10$

选择三个队列头最小的数$3$加入丑数数组，同时将该最小的数乘以$2,3,5$放入三个队列；

（3）
丑数数组：$1,2,3$
乘以2的队列：$4,6$
乘以3的队列：$6,9$
乘以5的队列：$5,10,15$

选择三个队列头里最小的数$4$加入丑数数组，同时将该最小的数乘以$2,3,5$放入三个队列；

（4）
丑数数组：$1,2,3,4$
乘以$2$的队列：$6，8$
乘以$3$的队列：$6,9,12$
乘以$5$的队列：$5,10,15,20$

选择三个队列头里最小的数5加入丑数数组，同时将该最小的数乘以$2,3,5$放入三个队列；

（5）
丑数数组：$1,2,3,4,5$
乘以$2$的队列：$6,8,10，$
乘以$3$的队列：$6,9,12,15$
乘以$5$的队列：$10,15,20,25$

选择三个队列头里最小的数$6$加入丑数数组，但我们发现，有两个队列头都为$6$，所以我们弹出两个队列头，同时将$12,18,30$放入三个队列；

疑问：

1.为什么分三个队列？

丑数数组里的数一定是有序的，因为我们是从丑数数组里的数乘以$2,3,5$选出的最小数，一定比以前未乘以$2,3,5$大，同时对于三个队列内部，按先后顺序乘以$2,3,5$分别放入，所以同一个队列内部也是有序的；

2.为什么比较三个队列头部最小的数放入丑数数组？

因为三个队列是有序的，所以取出三个头中最小的，等同于找到了三个队列所有数中最小的。

实现思路：

我们没有必要维护三个队列，只需要记录三个指针显示到达哪一步；“|”表示指针,arr表示丑数数组；

（1）
1

|2
|3
|5

目前指针指向$0,0,0$，队列头$arr[0]\times 2=2,arr[0]\times 3=3,arr[0]\times 5=5$

（2）
1 2

2 |4
|3 6
|5 10

目前指针指向$1,0,0$，队列头$arr[1]\times 2=4,arr[0]\times 3=3,arr[0]\times 5=5$

（3）
1 2 3

2| 4 6
3 |6 9
|5 10 15

目前指针指向$1,1,0$，队列头$arr[1]\times 2=4,arr[1]\times 3=6,arr[0]\times 5=5$

class Solution {
public:
    int GetUglyNumber_Solution(int index) {
        if(index < 7)
            return index;
        int it2 = 0, it3 = 0, it5 = 0;
        vector<int> v(index);
        v[0] = 1;
        for(int i = 1; i < index; i++)
        {
            v[i] = min(v[it2] * 2, min(v[it3] * 3, v[it5] * 5));
            if(v[i] == v[it2] * 2)
                it2++;
            if(v[i] == v[it3] * 3)
                it3++;
            if(v[i] == v[it5] * 5)
                it5++;
        }
        return v[index - 1];
    }
};

总结

写算法要有发散思维，找规律最重要；

保证求解算法的严谨度即可解答问题；

将纸上的模拟算法落实到程序上是一个思维的重大转变。