LeetCode264. 丑数 II

题目

编写一个程序，找出第 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];
    }

}