题目描述

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

因为丑数只有2、3和5这三个因子，那么如果一个是丑数的话，一定是可以被这个三个因子整除的，所以我们可以通过把一个数一直被三个因子除，这样最后如果该数变成1的话（因为第一个丑数是1），那么就验证了该数就是丑数。那么如果想找出第k个丑数的话，就可以从第一个数开始循环，对每一个数进行丑数的判断，从而找到符合要求的第k个丑数。下面是这种思路的代码实现：

public int GetUglyNumber_Solution2(int index) {
        if (index <= 0)
            return 0;
        int number = 0;
        int uglyNumCount = 0;
        while (uglyNumCount < index) {
            number++;
            if (isUglyNumber(number)) {
                uglyNumCount++;
            }
        }
        return number;
    }

    private boolean isUglyNumber(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;
    }

这种算法在我提交的时候出现了运行超时的情况，仔细分析发现，我们队每一个数都做了丑数的判断，而且判断一个丑数需要经历三个循环，这是导致性能瓶颈的关键，那么有没有可能使用其他的方法判断呢？我们可以维护一个从小到大的丑数列表，每次得到一个新的丑数之后，就更新这个列表，这个列表的更新思路是：因为丑数只有以上三个因子，所以在排序的丑数列表中，后面的某个丑数一定是前面某个丑数乘以2或3或5的结果，所以我们可以以这三个因子得到不同的丑数，然后把乘以2或3或5的得到的丑数进行排序，把最小的丑数更新到丑数列表中；如果列表的某个丑数乘以2或3或5的结果刚好是丑数中的最小值，那么就继续把该数对应的下标增加1，表示继续寻找下一个新的丑数。

下面是基于这种思路的实现代码（已被牛客AC）：

public int GetUglyNumber_Solution(int index) {
        if (index <= 0)
            return 0;
        int[] uglyNumbers = new int[index];
        uglyNumbers[0] = 1;
        int nextUglyNumberIndex = 1;
        int multiplyNumber2 = 0;
        int multiplyNumber3 = 0;
        int multiplyNumber5 = 0;
        while (nextUglyNumberIndex < index) {
            int min = min(uglyNumbers[multiplyNumber2] * 2,
                    uglyNumbers[multiplyNumber3] * 3,
                    uglyNumbers[multiplyNumber5] * 5);
            uglyNumbers[nextUglyNumberIndex] = min;
            nextUglyNumberIndex++;
            if (uglyNumbers[multiplyNumber2] * 2 == min)
                ++multiplyNumber2;
            if (uglyNumbers[multiplyNumber3] * 3 == min)
                ++multiplyNumber3;
            if (uglyNumbers[multiplyNumber5] * 5 == min)
                ++multiplyNumber5;

        }
        return uglyNumbers[nextUglyNumberIndex - 1];
    }

    private int min(int multiplyNumber2, int multiplyNumber3,
            int multiplyNumber5) {
        int min = (multiplyNumber2 < multiplyNumber3) ? multiplyNumber2
                : multiplyNumber3;
        return (min < multiplyNumber5) ? min : multiplyNumber5;
    }