Leetcode -Ugly Number II

My code:

public class Solution {
    public int nthUglyNumber(int n) {
        if (n <= 0)
            return 0;
        else if (n == 1)
            return 1;
        int i2 = 0;
        int i3 = 0;
        int i5 = 0;
        int[] ugly = new int[n];
        ugly[0] = 1;
        for (int i = 1; i < n; i++) {
            int temp = Math.min(2 * ugly[i2], Math.min(3 * ugly[i3], 5 * ugly[i5]));
            if (temp == 2 * ugly[i2]) {
                i2++;
            }
            if (temp == 3 * ugly[i3]) {
                i3++;
            }
            if (temp == 5 * ugly[i5]) {
                i5++;
            }
            ugly[i] = temp;
        }
        return ugly[n - 1];
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        System.out.println(test.nthUglyNumber(7));
    }
}

My test result:

Paste_Image.png

这个做法不是我一开始的做法。但是这个做法速度更快更高效。我也是看了提示才写出来的。

Paste_Image.png

可以仔细看下这个网页：
http://www.geeksforgeeks.org/ugly-numbers/

下面说下我的做法。使用一个优先级队列。
然后1，进队列，弹出。
然后 将弹出值temp分别 *2, 3, 5.
同时建立一个哈希表，并且判断这几个值在哈希表中是否存在过了，如果没有，则插入优先级队列。
差不多就是这么个思想。
代码是：

import java.util.HashSet;
import java.util.PriorityQueue;

public class Solution_slow {
    public int nthUglyNumber(int n) {
        if (n <= 0)
            return 0;
        else if (n == 1)
            return 1;
        PriorityQueue q = new PriorityQueue();
        HashSet h = new HashSet();
        long[] result = new long[n];
        int count = 0;
        q.add((long) 1);
        h.add((long) 1);
        while (count < n) {
            long temp = q.poll();
            result[count] = temp;
            count++;
            if (!h.contains(temp * 2)) {
                q.add(temp * 2);
                h.add(temp * 2);
            }
            if (!h.contains(temp * 3)) {
                q.add(temp * 3);
                h.add(temp * 3);
            }
            if (!h.contains(temp * 5)) {
                q.add(temp * 5);
                h.add(temp * 5);
            }
        }
        return (int) result[n - 1];
    }
    
    public static void main(String[] args) {
        Solution_slow test = new Solution_slow();
        System.out.println(test.nthUglyNumber(1407));
    }
}

My test result:

明显可以看出，慢了许多。
问题出在哪里呢？出在，我需要不断地判断，乘出来的数字是不是已经在优先级队列里出现过了。
但是最上面的算法不需要考虑这个。
如果 2* ugly[i2] = 3 * ugly[i3]
那么，两个if语句都会进入，i2,i3都会加1.
所以不会重复。

**
总结： DP
**

Anyway, Good luck, Richardo!

My code:

public class Solution {
    public int nthUglyNumber(int n) {
        if (n <= 0)
            return 0;

        int[] ugly = new int[n];        
        ugly[0] = 1;
        int u2 = ugly[0] * 2;
        int u3 = ugly[0] * 3;
        int u5 = ugly[0] * 5;
        int i2 = 0;
        int i3 = 0;
        int i5 = 0;
        for (int i = 1; i < n; i++) {
            int ug = Math.min(u2, Math.min(u3, u5));
            ugly[i] = ug;
            if (ug == u2) {
                i2++;
                u2 = ugly[i2] * 2;
            }
            if (ug == u3) {
                i3++;
                u3 = ugly[i3] * 3;
            }
            if (ug == u5) {
                i5++;
                u5 = ugly[i5] * 5;
            }
        }
        return ugly[n - 1];
    }
}

没做出来。
主要问题在于，我也想到了用三个链表，但是三个链表各自是以什么规则生成的。我不知道。
其实三个链表是伴随着 ugly[] 的扩大而扩大的。
是需要 ugly[] 数组的帮助的。
具体看上面那个链接把。下次做应该能做出来了。

Anyway, Good luck, Richardo!

My code:

public class Solution {
    public int nthUglyNumber(int n) {
        if (n <= 0) {
            return 0;
        }
        
        int i2 = 0;
        int i3 = 0;
        int i5 = 0;
        
        int[] ug = new int[n];
        ug[0] = 1;
        for (int i = 1; i < n; i++) {
            int temp = Math.min(2 * ug[i2], Math.min(3 * ug[i3], 5 * ug[i5]));
            if (temp == 2 * ug[i2]) {
                i2++;
            }
            if (temp == 3 * ug[i3]) {
                i3++;
            }
            if (temp == 5 * ug[i5]) {
                i5++;
            }
            ug[i] = temp;
        }
        
        return ug[n - 1];
    }
}

这道题目还是没能做出来。只记得用三个链表。。

其实不是链表。
首先需要思考， ugly number 到底如何生成的。
正如上面的解释所说。
[1,2,3,4,5,6,8,....]
*2
*3
*5
可以生成所有的ugly number
所以我们利用这个动态生成的数组，不断地生成新的数插入进去。
那么如果保证不遗漏呢？
那么2, 3, 5必须 乘过 该ugly array 里面的所有数，从小到大。
这样可以保证不遗漏。
但是又出现了一个问题：
会有重复情况。
所以如果 ug[i2] * 2 == ug[i3] * 3
那么， i2, i3 两个指针都需要移动。
我一开始写成了

if
else if
else

是错的。
改成：
if
if
if

就AC了。
这的确也算是DP。
Anyway, Good luck, Richardo! -- 08/27/2016