剑指offer—丑数

题目

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

题中丑数的定义是值包含质因子2、3、5的数，求解第N个数。
拿到该题第一想法是一次罗列出1、2、3……N个丑数，最后一个数即为要求的数，大致思路如下：

1. 初始版

比如判断某个数是否是丑数

/**
 * 判断某个数是否是丑数
 **/
public boolean isUgly(int number){
    while(number % 2 == 0 ){
        number = number / 2;
    }
    while(number % 3 == 0 ){
        number = number / 3;
    }
    while(number % 5 == 0 ){
        number = number / 5;
    }
    return number == 1 ? true : false;
}

然后一个一个数判断：

public class Sword031GetUglyNumber {
    public int GetUglyNumber_Solution(int index) {
        int total = 0;
        int number = 1;
        boolean result = false;
        while(total <= index){
            result = isUgly(number);
            if(result){
                total++;
            }
            number++;
        }
        return number;
    }
}

该方法优点是比较简单直接，依次判断每个数，做累加，但是时间复杂度较高，相当于把每个数都需要遍历一次。初步估计时间复杂度是$O(N^2)$，而且实际运行也确实会超时。

2. 改进版

上一个初始版，最费劲的是每次到下一个数都需要判断一下是否是丑数，之前计算的数据完全没有用上，但是实际上某个丑数肯定是另一个丑数乘以2（或者乘以3、或者乘以5）。
第二点：题目中要求的是求解第N个丑数，如果求解某个丑数的时候想要利用上之前的丑数，需要将之前的丑数存储起来，并且按照顺序存储，如果是无序，怎么知道在求解某个数是否是丑数时候应该乘谁呢？
第三点：如果求解下一个丑数呢，比如目前有三个丑数 {1, 2 , 3}，按照上一步思想，下一个丑数，肯定需要乘以2或者3或者5。

1. 如果乘以2，则 待选序列变成 {2，4， 6 }
2. 如果乘以3，则待选序列 变成 {3，6， 9 }
3. 如果乘以5，则待选序列变成 {5，10，15}

理论上需要从这么多数中选择最小的数，如果直接这么比较，筛选出来的数为2，但是2已经在原来排好序的丑数数组中，肯定会重复的。
因此需要继续考虑将已在丑数数组中的数排除掉，最好是比现在最大的丑数(不妨定义为：uglyNow)大那么一点点。。
找出第k个丑数，使得(k-1)个丑数比uglyNow小，但是第k个丑数比uglyNow大。(这一步是关键，理论需要一个简单的while循环筛选)

方法总结：根据以上的思想，现在需要考虑几点

• 必须建一个数组
• 必须寻找下一个刚好等于现在最大丑数的下标
• 从第二步中寻找最小的丑数。

---

---

---

基于以上分析写出如下代码：

public int GetUglyNumber_Solution(int index) {
    
    // 快速返回，俗称防御性编程
    if(index <= 0){
        return 0;
    }
    
    // 保存现在的丑数，有序的
    int[] num = new int[index];
    
    // 根据现有的定义设置第一个丑数
    num[0] = 1;
    int nextIndex = 1;
    
    // 分别用三个数值表示需要待乘数下标
    int index2 = 0;
    int index3 = 0;
    int index5 = 0;
    while(nextIndex < index){
        int min = min(num[index2]*2,num[index3]*3,num[index5]*5);
        num[nextIndex] = min;
        //  接下来需要寻找下一个x 2|3|5的下标
        while(num[index2]*2 <= num[nextIndex] ){
            ++index2;
        }
        while(num[index3]*3 <= num[nextIndex] ){
            ++index3;
        }
        while(num[index5]*5 <= num[nextIndex] ){
            ++index5;
        }
        ++nextIndex;
    }
    int ugly = num[nextIndex - 1];
    return ugly;
}


public int min(int a,int b, int c){
    int min = Math.min(a,b);
    return Math.min(min,c);
}

根据以上的分析，对于该方法是不是似曾相识呢，建一个空间，寻找下一个丑数(递推公式)。

根据以上两个特点，感觉和动态规划很相似吧，所以尝试利用动态规划解题。

public int GetUglyNumber_Solution(int index) {
    if(index <= 0){
        return 0;
    }
    int[] nums = new int[index];
    nums[0] = 1;
    int index2 = 0;
    int index3 = 0;
    int index5 = 0;
    for(int i = 1;i < index;i++){
        nums[i] = min(nums[index2]*2,nums[index3]*3,nums[index5]*5);
        // 看代码的时候，可以思考一下为什么这里可以利用if判断？
        if(nums[i] == nums[index2]*2){
            index2++;
        }
        if(nums[i] == nums[index3]*3){
            index3++;
        }
        if(nums[i] == nums[index5]*5){
            index5++;
        }
    }
    return nums[index-1];
}

代码中利用if判断，而不是利用while判断，是因为只要是丑数，乘以(2、3、5)中的任意一个数，肯定会等于刚刚计算的新的丑数。只要> 越过该值就可以避免下一次计算的丑数小于现在丑数的最大值。

总结

到目前为止，该题从我的角度看，已经解决了，主要是利用空间换时间，需要仔细思考其中的规律。
同样需要从有限的数据中寻找规律。