LeetCode：Super Ugly Number系列

1、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:

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.
An ugly number must be multiplied by either 2, 3, or 5 from a smaller ugly number.
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.
Assume you have Uk, the kth ugly number. Then Uk+1 must be Min(L1 * 2, L2 * 3, L3 * 5).

http://www.cnblogs.com/grandyang/p/4743837.html
每个子列表都是一个丑陋数分别乘以2,3,5，而要求的丑陋数就是从已经生成的序列中取出来的，我们每次都从三个列表中取出当前最小的那个加入序列。

充分理解题目给的提示即可，找出上面的规律，着重思考丑陋数的衍生。要得到vector最后一个数字，back()函数即可。注释掉的代码是dp解法，注意INT_MAX（头文件limits.h)使用。

class Solution {
public:
    int nthUglyNumber(int n) {
        /*
        *2   1*2 2*2 3*2 4*2
        *3   1*3 2*3 3*3 4*3
        *5   1*5 2*5 3*5 4*5
        *乘数来自ugly
        *select min one from the list
        */
        vector<int> ugly(1,1);
        int i2=0,i3=0,i5=0;
        while(ugly.size()<n)
        {
            int m2=ugly[i2]*2,m3=ugly[i3]*3,m5=ugly[i5]*5;
            int m=min(m2,min(m3,m5));
            if(m==m2)
            {
                ++i2;
            }
            if(m==m3)
            {
                ++i3;
            }
            if(m==m5)
            {
                ++i5;
            }
            ugly.push_back(m);
        }
        return ugly.back();//the last value
        // vector<int> ugly(n,INT_MAX);
        // ugly[0]=1;
        // int index[3]{};
        // int primes[3]{2,3,5};
        // for(int i=1;i<n;++i)
        // {
        //     for(int j=0;j<3;++j)
        //     {
        //         ugly[i]=min(ugly[i],ugly[index[j]]*primes[j]);
        //     }
        //     for(int j=0;j<3;++j)
        //     {
        //         if(ugly[i]==ugly[index[j]]*primes[j])
        //         {
        //             ++index[j];
        //         }
        //     }
        // }
        // return ugly[n-1];
    }
};

---

2、Super Ugly Number

Write a program to find the nth super ugly number.

Super ugly numbers are positive numbers whose all prime factors are in the given prime list primes of size k. For example, [1, 2, 4, 7, 8, 13, 14, 16, 19, 26, 28, 32] is the sequence of the first 12 super ugly numbers given primes = [2, 7, 13, 19] of size 4.

Note:
(1) 1 is a super ugly number for any given primes.
(2) The given numbers in primes are in ascending order.
(3) 0 < k ≤ 100, 0 < n ≤ 106, 0 < primes[i] < 1000.

http://blog.csdn.net/ciaoliang/article/details/50177735
用一个指针数组来记录每个质数乘积的次数，用另一个数字存储解。
时间复杂度O(nk)，空间O(n)+O(k)

第一部分代码是根据上一个解决方法写出来的，第二部分是参考引用的写出，第三部分，自己写的。只有自己写的超时了，看了别人写的后落差太大。其实第二部分代码就是根据第一部分演变而来。

Reference
http://www.cnblogs.com/grandyang/p/5144918.html

我们可以发现，index与point如出一辙，都是标识该子序列走到了哪一索引，也就是引用所说的使用次数。

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        vector<int> ugly(1,1);
        int len=primes.size();
        vector<int> index(len,0),res(len);
        while(ugly.size()<n)
        {
            for(int i=0;i<len;++i)
            {
                res[i]=ugly[index[i]]*primes[i];
            }
            int minp=*min_element(res.begin(),res.end());
            for(int i=0;i<len;++i)
            {
                if(minp==ugly[index[i]]*primes[i])
                {
                    ++index[i];
                }
            }
            ugly.push_back(minp);
        }
        return ugly.back();
        // int len = primes.size();  
        // vector<int> point(len,0);  
        // vector<int> ugly(n,INT_MAX);  
        // ugly[0]=1;  
        // for(int i=1; i<n; ++i)
        // {  
        //     for(int j=0; j<len; ++j) 
        //     {
        //         ugly[i] = min(ugly[i],ugly[point[j]]*primes[j]);  
        //     }
        //     for(int j=0; j<len; ++j)  
        //     {
        //         if(ugly[i] == ugly[point[j]]*primes[j])
        //         {  
        //             ++point[j];  
        //         } 
        //     }
        // }  
        // return ugly[n-1]; 

        // vector<int> superUglyNumber(n);
        // superUglyNumber[0]=1;
        // int len=primes.size();
        // for(int i=2,j=1;j<n;++i)
        // {
        //     int m=i,lastM=i;
        //     while(m!=1)
        //     {
        //         for(int k=1;k<j;++k)
        //         {
        //             if(m%superUglyNumber[k]==0)
        //             {
        //               m/=superUglyNumber[k];
        //               break;
        //             }
        //         }
        //         if(m==lastM)
        //         {
        //             if(i<=primes[len-1])
        //             {
        //                 for(int t=0;t<len;++t)
        //                 {
        //                     if(primes[t]==i)
        //                     {
        //                         superUglyNumber[j++]=i;
        //                         break;
        //                     }
        //                 }
        //             }
        //             break;
        //         }
        //         else
        //         {
        //             lastM=m;
        //         }
        //     }
        //     if(m==1)
        //     {
        //         superUglyNumber[j++]=i;
        //     }       
        // }
        // return superUglyNumber[n-1];
    }
};