題目

編寫一個程式，找出第 n 個醜數。

醜數就是隻包含質因數 2, 3, 5 的正整數。

示例:

輸入: n = 10
輸出: 12
解釋: 

1, 2, 3, 4, 5, 6, 8, 9, 10, 12

 是前 10 個醜數。

說明:  

1. 1 是醜數。
2. n 不超過1690。

分析

我  就只會暴力解決，但是暴力解決的時間複雜度為n^3，會超時的吖。

暴力解決就是在從數字1開始，一個一個一個的找，哪個數字是醜數，在找醜數的時候，我需要知道它是不是素數，不是素數又是不是某些素數的整數倍，這樣會來三層迴圈。

那一個一個的找是不太可能了，只能換一種方法，生成醜數列表吧。

我們可以發現，每個醜數都是由某個醜數和2 3 5 相乘的結果，那麼我們就可以利用已有的醜數列表和2 3 5相乘，來不斷生成新的醜數。

那比如說我們的已有醜數：[1 2 3 4 5]，我們怎麼找下一個醜數呢，首先我們最後一個醜數為 5

a.陣列中每個數字分別×2 ，得[ 2 4 6 8 10]， 找出第一個大於5的數， m2 = 6;

b.陣列中每個數字分別×3 ，得[ 3 6 9 12 15]， 找出第一個大於5的數， m3 = 6;

c.陣列中每個數字分別×5 ，得[ 5 10 15 20 25]， 找出第一個大於5的數， m5 =10;

d.m2 m3 m5 中最小數，m2 =  6，則 6為下一個醜數。

ugly[i] = min( ugly[x]*2, ugly[y]*3, ugly[z]*5 )

這裡  x = min( x1, x2, x3…… )  ugly[ x1 ] * 2 > ugly[ i-1 ] ,ugly[ x2 ] * 2 > ugly[ i-1 ] ,ugly[ x3 ] * 2 > ugly[ i-1 ] ……

         x = min( y1, y2, y3…… )  ugly[ y1 ] * 2 > ugly[ i-1 ] ,ugly[ y2 ] * 2 > ugly[ i-1 ] ,ugly[ y3 ] * 2 > ugly[ i-1 ] ……

         x = min( z1, z2, z3…… )  ugly[ z1 ] * 2 > ugly[ i-1 ] ,ugly[ z ] * 2 > ugly[ i-1 ] ,ugly[ z3 ] * 2 > ugly[ i-1 ] ……

當然我們上面生成醜數的過程是比較方便理解的，可是它會做很多沒有必要的迭代計算，上面的方法可以優化，優化後的時間複雜度可以降到on。

我自己寫的沒有優化的很好，只是把時間複雜度降到了On^2,提交了之後發現其它人的程式碼，是自己沒有優化到底，就把程式碼貼下面吧。

程式碼

int[] ugly = new int[n];

        ugly[0] = 1;
        int mA = 0; int mB = 0; int  mC = 0;
        int count = 1;

        while(count < n){
            boolean fA = false, fB = false, fC = false;
            for (int i = 0; ; i++) {

                if (ugly[i] * 2 > ugly[count-1] && fA == false){
                    fA = true;
                    mA = ugly[i] * 2;
                }
                if (ugly[i] * 3 > ugly[count-1] && fB == false){
                    fB = true;
                    mB = ugly[i] * 3;
                }
                if (ugly[i] * 5 > ugly[count-1] && fC == false){
                    fC = true;
                    mC = ugly[i] * 5;
                }
                if (fA&&fB&&fC) break;
            }

            ugly[count++] = Math.min(mA,Math.min(mB,mC));
            
        }

        Util.forPirnt(ugly);

        return ugly[n-1];

class Solution {
    public  int min(int a,int b,int c){
        return a>b?(b<c?b:c):(a<c?a:c);
    }
    public int nthUglyNumber(int n) {
        int[] u=new int[n];
        u[0]=1;
        int index2=0;
        int index3=0;
        int index5=0;
        int k=1;
        while(k<n){
            u[k]=min(u[index2]*2,u[index3]*3,u[index5]*5);
            if(u[index2]*2==u[k])index2++;
            if(u[index3]*3==u[k])index3++;
            if(u[index5]*5==u[k])index5++;
            k++;
        }
        return u[n-1];
    }

}