丑数[数据加强版]

丑数[数据加强版]

Description

对于一给定的素数集合 S = {p1, p2, ..., pK}, 来考虑那些质因数全部属于S 的数的集合。 这个集合包括:p1, p1p2, p1p1, 和 p1p2p3 (还有其它)。这是个对于一个输入的S的丑数集 合。注意：我们不认为1 是一个丑数。 你的工作是对于输入的集合S去寻找集合中的第N个丑数。long long对于 程序是足够的。

Input

第 1 行: 二个被空隔分开的整数:K 和 N ， 1<= K<=100 ， 1<= N<=3,000,000. 第 2 行: K 个被空隔分开的整数:集合S的元素

Output

单独的一行，写上对于输入的S的第N个丑数。

Sample Input

4 19
2 3 5 7

Sample Output

27

HINT

Source

//
//  f.cpp
//  noip
//
//  Created by lijian3256 on 2020/1/11.
//  Copyright © 2020 lijian3256. All rights reserved.
//
 
#include<bits/stdc++.h>
using namespace std;
  
const int maxcount = 3000001;
long long r[maxcount];
  
int heap[101];
int heapsize = 0;
  
void put(int n)
{
    heap[heapsize + 1] = n;
    heapsize ++;
    int now = heapsize;
    while(now > 1)
    {
        int parent = now >> 1;
        if(heap[parent] <= heap[now])
        {
            return;
        }
        else
        {
            swap(heap[parent], heap[now]);
            now = parent;
        }
    }
}
  
int get()
{
    if(heapsize < 1)
        {
            cout << "error";
            return -1;
        }
    int r = heap[1];
      
    heap[1] = heap[heapsize];
    heapsize--;
    int now = 1;
      
    while(now*2 <= heapsize)
    {
        int son1 = now * 2;
        int son2 = son1 + 1;
        int smallerson = son1;
        if(son2 <= heapsize)
        {
            if(heap[son1] > heap[son2])
            {
                smallerson = son2;
            }
            else
                smallerson = son1;
        }
          
        if(heap[smallerson] < heap[now])
        {
            swap(heap[smallerson], heap[now]);
            now = smallerson;
        }
        else
        {
            return r;
        }
    }
    return r;
}
  
  
struct T
{
    long long n;
    int i;
    int j;
};
T  heap2[101];
int heapsize2 = 0;
  
int find(long long n, int start, int end)
{
    if (start == end)
    {
        if(heap2[start].n == n)
            return -1;
        else if(heap2[start].n > n)
            return start+1;
        else
            return start;
    }
    int m = (start + end) / 2;
    if(heap2[m].n == n)
        return -1;
    else if(heap2[m].n > n)
    {
        if(m + 1 > end)
            return m+1;
        else
            return find(n, m + 1, end);
    }
    else
    {
        if(start > m-1)
            return start;
        else
            return find(n, start, m - 1);
    }
}
  
bool put2(long long n, int i, int j)
{
    int k;
    if(heapsize2 < 1)
        k = 1;
    else
        k = find(n, 1, heapsize2);
    if ( k == -1)
        return false;
    else
    {
        T node;
        node.n = n;
        node.i = i;
        node.j = j;
        for(int c=heapsize2;c>=k;c--)
            heap2[c+1] = heap2[c];
        heap2[k] = node;
        heapsize2++;
        return true;
    }
}
  
  
  
T get2()
{
    return heap2[heapsize2--];
      
}
  
int main()
{
    int P[101];
    int K, N;
    int temp;
    cin >> K >> N;
    for(int i=1;i<=K;i++)
    {
        cin >> temp;
        put(temp);
    }
      
    for(int i=1;i<=K;i++)
        P[i] = get();
      
      
    for(int i=1;i<=K;i++)
    {
        put2(P[i], P[i], 0);
    }
      
  
    int nn = 0;
  
    while(nn <= N)
    {
        T t = get2();
        if(t.n > r[nn])
        {
            r[++nn] = t.n;
        }
          
        int j = t.j + 1;
        while(! put2(t.i * r[j], t.i, j))
        {
            j++;
        }
    }
      
    cout << r[N];
    //cout << pp << " " << r[N] << " " << N;
    return 0;
}
 
/**************************************************************
    Problem: 1499
    User: LJA001162
    Language: C++
    Result: 正确
    Time:1568 ms
    Memory:24980 kb
****************************************************************/