题目
编写一个程序，找出第
n个丑数。丑数就是只包含质因数
2, 3, 5的正整数。示例:
输入: n = 10 输出: 12 解释:1, 2, 3, 4, 5, 6, 8, 9, 10, 12是前 10 个丑数。说明:
1是丑数。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];
}
}