剑指offer第三十三题丑数

题目描述

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

题目分析

说下思路，如果p是丑数，那么p=2^x * 3^y * 5^z，那么只要赋予x,y,z不同的值就能得到不同的丑数。
如果要顺序找出丑数，要知道下面几个特（fei）点（hua）。
对于任何丑数p：
a.那么2*p,3*p,5*p都是丑数，并且2*p<3*p<5*p
b.如果p<q, 那么2*p<2*q,3*p<3*q,5*p<5*q
现在说说算法思想：
    由于1是最小的丑数，那么从1开始，把2*1，3*1，5*1，进行比较，得出最小的就是1的下一个丑数，也就是2*1，
    这个时候，多了一个丑数‘2’，也就又多了3个可以比较的丑数，2*2，3*2，5*2，这个时候就把之前‘1’生成的丑数和‘2’生成的丑数加进来也就是(3*1,5*1,2*2，3*2，5*2)进行比较，找出最小的。。。。如此循环下去就会发现，每次选进来一个丑数，该丑数又会生成3个新的丑数进行比较。上面的暴力方法也应该能解决，但是如果在面试官用这种方法，估计面试官只会摇头吧。下面说一个O（n）的算法。在上面的特（fei）点（hua）中，既然有p<q, 那么2*p<2*q，那么“我”在前面比你小的数都没被选上，你后面生成新的丑数一定比“我”大吧，那么你乘2生成的丑数一定比我乘2的大吧，那么在我选上之后你才有机会选上。其实每次我们只用比较3个数：用于乘2的最小的数、用于乘3的最小的数，用于乘5的最小的数。也就是比较(2*x , 3*y, 5*z) ，x>=y>=z的.

class Solution {
public:
    int GetUglyNumber_Solution(int index) {
        if(index<=0) return 0;
        if(index==1) return 1;
        vector<int> k(index);k[0]=1;
        int t2=0,t3=0,t5=0;
        for(int i=1;i<index;i++){
            k[i]=min(k[t2]*2,min(k[t3]*3,k[t5]*5));
            if(k[i]==k[t2]*2) t2++;
            if(k[i]==k[t3]*3) t3++;
            if(k[i]==k[t5]*5) t5++;
        }
        return k[index-1];
    }
};

还有一种分析

思想就是用已知的丑数去生成丑数，然后把丑数排序就好了。先来一发毫无技巧的代码：生成第i个丑数时，都从第一个丑数往后扫描，分别用2, 3, 5去乘，如果结果大于arr[i - 1]，就维护一个最小值，扫描完后，这个最小值就是第i个丑数。
时间复杂度：O(n^2)。

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

还有更优的方法，不知你注意到了没，我们要寻找一个数乘以2, 3, 5大于arr[i - 1]且这个数最小，这个操作是不需要每次都从数组头开始找的，而且也不要每次都找到i - 1处。现在把问题简化一下，只考虑用2去乘，那么我们总可以在数组中找到一个位置pos，这个位置上的数乘2刚好大于arr[i - 1]，往后的数字就不需要去计算了，因为越往后数字越大，乘起来的结果也就越大，故不满足该数最小这个条件，因此pos处的数乘2就是arr[i]，现在把pos记录下来，下一次扫描的时候就要求arr[i + 1]了，这时候就要寻找一个数乘以2大于arr[i]且这个数最小，而arr[pos] * 2 = arr[i]，所以满足条件的当然就是arr[i + 1] = arr[pos + 1] * 2，这样子查找的时间复杂度就降到了O(1)O(1)；
现在再把那个简化的问题恢复为原问题，用2, 3, 5去乘，那么不是就维护三个pos分别对应2, 3, 5就行了吗，每次都去比较这三个位置乘出来的结果，取最小的就行了，然后用这个最小的结果取和这三个位置乘出来的结果比较，如果相等就往后移动对应的pos。
时间复杂度：O(n)。

class Solution {
public:
    int GetUglyNumber_Solution(int index) {
        if (index == 0)
            return 0;
        vector<int> arr(index, 1), ptr(3, 0), num({2, 3, 5});
        for (int cnt = 1, min_value; cnt < index; arr[cnt++] = min_value) {
            vector<int> result(3);
            for (int i = 0; i < 3; result[i] = arr[ptr[i]] * num[i], ++i);
            min_value = *min_element(result.begin(), result.end());
            for (int i = 0; i < 3; ptr[i] += min_value == result[i], ++i);
        }
        return arr[index - 1];
    }
};