264. Ugly Number II

题目：

Write a program to find the n-th ugly number.

Ugly numbers are positive numbers whose prime factors only include 2, 3, 5. For example, 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 is the sequence of the first 10 ugly numbers.

Note that 1 is typically treated as an ugly number.

Hint:

1. The naive approach is to call isUgly for every number until you reach the nth one. Most numbers are not ugly. Try to focus your effort on generating only the ugly ones.
2. An ugly number must be multiplied by either 2, 3, or 5 from a smaller ugly number.
3. The key is how to maintain the order of the ugly numbers. Try a similar approach of merging from three sorted lists: L1, L2, and L3.
4. Assume you have Uk, the kth ugly number. Then Uk+1 must be Min(L1 * 2, L2 * 3, L3 * 5).

题意：

写一个程序找到第n个“丑数”；

思路一：

一个最容易想到的方法，就是从1开始依次向后判断各自然数是否为丑数，一直判断到第n个丑数，返回第n个丑数的值。这种方法由于充斥了大量的重复计算，效率很低，因此会导致TLE（Time Limit Exceeded）的结果。

代码：java版：Time Limit Exceeded

public class Solution {
    public int nthUglyNumber(int n) {
        if(n<=1) return 1;
        
        int counter = 0;
        for (int i=1; ; i++){
            if(isUgly(i)){
                counter++;
                if(counter==n){
                    return i;
                }
            }
        }
    }
    
    public boolean isUgly(int num){
        if(num<=0) return false;
        
        while(num%2 == 0) num /= 2;
        while(num%3 == 0) num /= 3;
        while(num%5 == 0) num /= 5;
        
        if(num == 1){
            return true;
        }else{
            return false;
        }
    }
}

思路二：

1到N的丑数为 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, … ； 
可以分成如下三组：

(1) 1×2, 2×2, 3×2, 4×2, 5×2, …

(2) 1×3, 2×3, 3×3, 4×3, 5×3, …

(3) 1×5, 2×5, 3×5, 4×5, 5×5, …

只需要保证每次迭代的过程中选取最小的丑数（或者说是质因数），可以理解为后面的数字是前面的数组针对2,3,5的乘积。 

程序执行步骤：

1、申请一个长度为n的数组uglyNumbers，用于从小到大顺序存储n个丑数，数组中的首项为1，即第一个丑数为1

2、设置三个变量idx2、idx3、idx5存储下标，初始值都为0

3、找出数组uglyNumbers[idx2]*2、uglyNumbers[idx3]*3、uglyNumbers[idx5]*5的最小值，最小值即为下一个丑数，同时更新最小值对应的下标，如果多个数字同时为最小值，则它们的下标都要更新

4、找到第n个丑数时，循环结束。

代码：java版：11ms

public class Solution {
    public int nthUglyNumber(int n) {
        
        int[] uglyNumbers = new int[n];
        uglyNumbers[0] = 1;
        
        int idx2 = 0;
        int idx3 = 0;
        int idx5 = 0;
        
        int counter = 1;
        while(counter < n) {
            int min = minOf(uglyNumbers[idx2]*2, uglyNumbers[idx3]*3, uglyNumbers[idx5]*5);
            
            if(min == uglyNumbers[idx2]*2) idx2++;
            
            if(min == uglyNumbers[idx3]*3) idx3++;
            
            if(min == uglyNumbers[idx5]*5) idx5++;
            
            uglyNumbers[counter] = min;
            counter++;
        }
        
        return uglyNumbers[n-1];
    }
    
    private int minOf(int a, int b, int c){
        int temp = a<b ? a : b;
        return temp<c ? temp : c;
    }
}

代码：C++版：16ms

class Solution {
public:
    int nthUglyNumber(int n) {
        if(n <= 0) return false; // get rid of corner cases 
        if(n == 1) return true; // base case
        int t2 = 0, t3 = 0, t5 = 0; //pointers for 2, 3, 5
        vector<int> k(n);
        k[0] = 1;
        for(int i  = 1; i < n ; i ++)
        {
            k[i] = min(k[t2]*2,min(k[t3]*3,k[t5]*5));
            if(k[i] == k[t2]*2) t2++; 
            if(k[i] == k[t3]*3) t3++;
            if(k[i] == k[t5]*5) t5++;
        }
        return k[n-1];
    }
};