[Leetcode] Ugly Number II, Solution

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.

[Thoughts]

這就是多鏈表Merge Sort的一個擴展題。

對於任意一個ugly number - K, 2*K, 3*K, 和5*K都是ugly number，因此說新的ugly number都是從已有的ugly number上，經過與{2,3,5}相乘而產生的。

若是

Ugly Number:       1,         2,          3,           4,           5,           6,            8,         10,     ..............

那麼                      1* 2      2* 2        3* 2         4* 2         5* 2         6* 2         8* 2        10* 2  .............. *2

                              1*3       2*3         3* 3          4* 3         5* 3         6* 3          8* 3         10* 3    .............. *3

                              1*5       2* 5         3* 5          4* 5          5* 5          6* 5          8* 5         10* 5    .............. *5

都是ugly number。只要不斷把新產生的ugly number經過merge sort添加到原有的ugly number數組中就能夠了，直到找到第N個。

[Code] 

1:  class Solution {  
2:  public:  
3:    int nthUglyNumber(int n) {  
4:      vector<int> uglys(1, 1);  
5:      int p2 = 0, p3 = 0, p5 = 0;  
6:      while (uglys.size() < n) {  
7:        int ugly2 = uglys[p2] * 2, ugly3 = uglys[p3] * 3, ugly5 = uglys[p5] * 5;  
8:        int min_v = min(ugly2, min(ugly3, ugly5));  
9:        if (min_v == ugly2) ++p2;  
10:        if (min_v == ugly3) ++p3;  
11:        if (min_v == ugly5) ++p5;  
12:        if(min_v != uglys.back()) {  
13:          // skip duplicate  
14:          uglys.push_back(min_v);  
15:        }  
16:      }  
17:      return uglys[n-1];  
18:    }  
19:  };  

考慮到通用性，能夠擴展以下，能夠支持任意長度的因子數組factors。

1:  class Solution {  
2:  public:  
3:    int nthUglyNumber(int n) {  
4:      vector<int> factors{ 2, 3, 5};  
5:      return nthUglyNumberGeneral(n, factors);  
6:    }  
7:    int nthUglyNumberGeneral(int n, vector<int>& factors) {  
8:      vector<int> uglys(1,1);  
9:      vector<int> indexes(factors.size(), 0);  
10:      while(uglys.size() < n) {  
11:        int min_v = INT_MAX;  
12:        int min_index = 0;  
13:        for(int k =0; k< factors.size(); k++) {  
14:          int temp = uglys[indexes[k]] * factors[k];  
15:          if(temp < min_v) {  
16:            min_v = temp;  
17:            min_index = k;  
18:          }  
19:        }  
20:        indexes[min_index]++;  
21:        // need to avoid duplicate ugly number  
22:        if(uglys[uglys.size()-1] != min_v) {  
23:          uglys.push_back(min_v);  
24:         }  
25:      }  
26:      return uglys[n-1];  
27:    }  
28:  };  

從空間的優化來講，沒有必要用一個uglys的數組保存全部的ugly number，尤爲是當n是個很是大的數字。對於 indexes指針掃過的ugly number，均可以丟掉了。不過，懶得寫了。