醜數

把只包含因子 二、3 和 5 的數稱做醜數。例如 六、8 都是醜數，但 14 不是，由於它包含因子 7。習慣上咱們把 1 當作是第一個醜數。求按從小到大的順序的第 N 個醜數。

思路：

連接：https://www.nowcoder.com/questionTerminal/6aa9e04fc3794f68acf8778237ba065b?f=discussion
來源：牛客網
 

通俗易懂的解釋：

首先從醜數的定義咱們知道，一個醜數的因子只有2,3,5，那麼醜數p = 2 ^ x * 3 ^ y * 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] * 2 = 2,  arr[0] * 3 = 3,  arr[0] * 5 = 5

（2）1 2

2 |4

|3 6

|5 10

目前指針指向1,0,0，隊列頭arr[1] * 2 = 4,  arr[0] * 3 = 3, arr[0] * 5 = 5

（3）1 2 3

2| 4 6

3 |6 9

|5 10 15

目前指針指向1,1,0，隊列頭arr[1] * 2 = 4,  arr[1] * 3 = 6, arr[0] * 5 = 5

………………

class Solution {
public:
    int GetUglyNumber_Solution(int index) {
        // 0-6的醜數分別爲0-6
        if(index < 7) return index;
        //p2，p3，p5分別爲三個隊列的指針，newNum爲從隊列頭選出來的最小數
        int p2 = 0, p3 = 0, p5 = 0, newNum = 1;
        vector<int> arr;
        arr.push_back(newNum);
        while(arr.size() < index) {
            //選出三個隊列頭最小的數
            newNum = min(arr[p2] * 2, min(arr[p3] * 3, arr[p5] * 5));
            //這三個if有可能進入一個或者多個，進入多個是三個隊列頭最小的數有多個的狀況
            if(arr[p2] * 2 == newNum) p2++;
            if(arr[p3] * 3 == newNum) p3++;
            if(arr[p5] * 5 == newNum) p5++;
            arr.push_back(newNum);
        }
        return newNum;
    }
};

第二種方法：

/*
說下思路，若是p是醜數，那麼p=2^x * 3^y * 5^z
那麼只要賦予x,y,z不一樣的值就能獲得不一樣的醜數。
若是要順序找出醜數，要知道下面幾個特（fei）點（hua）。
對於任何醜數p：
（一）那麼2*p,3*p,5*p都是醜數，而且2*p<3*p<5*p
（二）若是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的，
重點說說下面代碼中p的做用：int p[] = new int[] { 0, 0, 0 }; p[0]表示最小用於
乘2比較數在數組a中的【位置】。 */
public class Solution {
    final int d[] = { 2, 3, 5 };
    public int GetUglyNumber_Solution(int index) {
        if(index == 0) return 0;
        int a[] = new int[index];
        a[0] = 1;
        int p[] = new int[] { 0, 0, 0 };
        int num[] = new int[] { 2, 3, 5 };
        int cur = 1;
 
        while (cur < index) {
            int m = finMin(num[0], num[1], num[2]);
            if (a[cur - 1] < num[m])
                a[cur++] = num[m];
            p[m] += 1;
            num[m] = a[p[m]] * d[m];
        }
        return a[index - 1];
    }
 
    private int finMin(int num2, int num3, int num5) {
        int min = Math.min(num2, Math.min(num3, num5));
        return min == num2 ? 0 : min == num3 ? 1 : 2;
    }
}