剑指offer——丑数（好题，思路）

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

思路：
似乎只能一个个判过去。
判断是否为丑数的时候，求因子时循环停止的条件是到平方根为止。（这么做会超时）

而且题目中应该指的是仅有质数因子2，3，5！所以8也是丑数

利用动态规划求解。

---

如果用普通思路的判断方法。

/*
说下思路，如果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中的【位置】。 p[1]表示3，p[2]表示5*/

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 };
        // num数组下标为0，1，2的三个数分别为*2，*3，*5得到的数
        int num[] = new int[] { 2, 3, 5 };
        int cur = 1;

        while (cur < index) {
            // 返回num数组中最小值的下标
            int m = finMin(num[0], num[1], num[2]);
            if (a[cur - 1] < num[m]) 
                // 更新丑数数组
                a[cur++] = num[m];
            // 更新数组p    
            p[m] += 1;
            // 因为num[m]已经被加入数组a，所以要对num[m]进行更新
            num[m] = a[p[m]] * d[m];
        }
        return a[index - 1];
    }


    private int finMin(int num1, int num2, int num3) {
        int min = Math.min(num1, Math.min(num2, num3));
        return min == num1 ? 0 : min == num2 ? 1 : 2;
    }
}

下面的方法，并没有维护之前那个方法所需要的num数组，而是每次都生成三个数，用于比较（生成三个数的规则仍然相同）

public int GetUglyNumber_Solution2(int n) //用list可能更好理解
    {
        if(n<=0)return 0;
        ArrayList<Integer> list=new ArrayList<Integer>();
        list.add(1);
        int i2=0,i3=0,i5=0;
        while(list.size()<n)//循环的条件
        {
            int m2=list.get(i2)*2;
            int m3=list.get(i3)*3;
            int m5=list.get(i5)*5;
            int min=Math.min(m2,Math.min(m3,m5));
            list.add(min);
            if(min==m2)i2++;
            if(min==m3)i3++;
            if(min==m5)i5++;
        }
        return list.get(list.size()-1);
    }

再来分步理解下这个问题，首先由三个基数，分别是2，3，5。然后第一个丑数定为1。我们要得到顺序的第n个丑数，所以要把这之间的都求出来。

对于任何丑数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开始，得到3个比较数，2，3，5；取最小的2放入list
此时list的数是1，2；
然后要得到下一个数字，此时，在进行迭代运算时，应该计算1*3，1*5，和2*2。 因为之前是用1*2得到的最小值，所以这个式子不应该再算一次。然后得到3，入list。
此时list的数是1，2，3
再进行迭代运算时，应计算1*5，2*2，2*3。