leecode 解题总结：313. Super Ugly Number

#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
using namespace std;
/*
问题:
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.
(4) The nth super ugly number is guaranteed to fit in a 32-bit signed integer.

分析:题目给定了一个长度为k的丑数列表，计算第n个丑数。
之前计算{2,3,5}的丑数是采用：设定3个指针分别先指向候选丑数列表{mul2,mul3,mul5}.
从中每次选择最小的作为丑数cand，
然后更新候选丑数列表，用2*mul2 <= cand,就累加指向候选丑数mul2的下标；
同理对3*mul3 <= cand,5*mul5 <= cand做同样处理。
对于此题，同理设定长度为k的指针，分别指向候选丑数列表，但是每一次比较就是
从k个里面选择一个最小的数作为候选数，然后对k个指针进行遍历和处理。
每一次时间复杂度为O(k)，总的时间复杂度为O(n*k)

输入:
4(给定的质数数组长度)  12(命令个数每个命令表示想要查询的第几个丑数)
2 7 13 19
1 2 3 4 5 6 7 8 9 10 11 12
输出:
1 2 4 7 8 13 14 16 19 26 28 32

关键:
1 之前计算{2,3,5}的丑数是采用：设定3个指针分别先指向候选丑数列表{mul2,mul3,mul5}.
从中每次选择最小的作为丑数cand，
然后更新候选丑数列表，用2*mul2 <= cand,就累加指向候选丑数mul2的下标；
同理对3*mul3 <= cand,5*mul5 <= cand做同样处理。
对于此题，同理设定长度为k的指针，分别指向候选丑数列表，但是每一次比较就是
从k个里面选择一个最小的数作为候选数，然后对k个指针进行遍历和处理。
*/

class Solution {
public:
	//从候选丑数列表中选择最小的丑数:indexs候选丑数列表的下标，primes:质数列表，uglyNumbers:已经生成的丑数列表
	int minNum(vector<int>& uglyNumbers ,  vector<int>& primes , vector<int>& indexs)
	{
		if(uglyNumbers.empty() || indexs.empty() || primes.empty() || indexs.size() != primes.size())
		{
			return 0;
		}
		int minValue = INT_MAX;
		int size = primes.size();
		for(int i = 0 ; i < size ; i++)
		{
			int index = indexs.at(i);
			if(0 <= index && index < uglyNumbers.size())
			{
				minValue = min(minValue , primes.at(i) * uglyNumbers.at(index) );
			}
		}
		return minValue;
	}

    int nthSuperUglyNumber(int n, vector<int>& primes) {
		if(n < 1 || primes.empty())
		{
			return 0;
		}
        vector<int> uglyNumbers(1,1);//初始化候选丑数列表
		int size = primes.size();
		//初始化长度为size的候选丑数下标数组，初始化均为0
		vector<int> indexs(size , 0);
		int count = 1;
		while(count < n)
		{
			int uglyNumber = minNum(uglyNumbers,primes , indexs);
			uglyNumbers.push_back(uglyNumber);
			//更新每一个候选丑数下标
			for(int i = 0 ; i < size ;  i++)
			{
				while(primes.at(i) * uglyNumbers.at( indexs.at(i) ) <= uglyNumber)
				{
					indexs.at(i)++;
				}
			}
			count++;
		}
		return uglyNumbers.at(n - 1);
    }
};


void process()
{
	 vector<int> nums;
	 int value;
	 int num;
	 int commandNum;
	 Solution solution;
	 int nTh;
	 while(cin >> num  >> commandNum)
	 {
		 nums.clear();
		 for(int i = 0 ; i < num ; i++)
		 {
			 cin >> value;
			 nums.push_back(value);
		 }
		 for(int i = 0 ; i < commandNum ; i++)
		 {
			 cin >> nTh;
			 int result = solution.nthSuperUglyNumber(nTh , nums);
			 cout << result << endl;
		 }
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}