USACO 3.1 humble

常规解法网上有

这里介绍堆解法

即

 每一趟，堆顶为第i小的丑数，弹出（用堆末和堆顶交换、 不多说）

             第i小的丑数分别乘以各个质数，判重后加入堆中 维护（上滑）

主要介绍判重：这里很明显要哈希，而且要拉链   因为丑数可能非常大 比如超过10^7 会MLE的

堆的维护不解释、、

比如4个质数 2 3 5 7 求第19小丑数

 1为堆顶，1弹出堆，乘以2 3 5 7分别加入堆

然后2为堆顶，弹出堆，乘以2 3 5 7

然后是3、4……

悲剧的是USACO 内存限制16MB 太抠了  test12 即最后一个点  MLE

如果把数组开大就TLE

空间和时间是有联系的嘛！

还有一种二叉堆的做法、 判重比较方便 不多说

如有神牛直接用堆（不是二叉堆）过了 恳请指点

{
ID: xiaweiy1
PROG: humble
LANG: PASCAL
}
const maxn=1000000;
      maxm=999985;
      maxx=1000000;
var p:array[0..100]of longint;
    k,n,i,done,tot,num,t,res,total,ttt:longint;
    heap:array[1..maxn]of longint;
    hash:array[1..maxm]of longint;
    lian:array[1..maxx,1..2]of longint;
procedure sort(l,r: longint);
      var
         i,j,x,y: longint;
      begin
         i:=l;
         j:=r;
         x:=p[(l+r) div 2];
         repeat
           while p[i]<x do
            inc(i);
           while x<p[j] do
            dec(j);
           if not(i>j) then
             begin
                y:=p[i];
                p[i]:=p[j];
                p[j]:=y;
                inc(i);
                j:=j-1;
             end;
         until i>j;
         if l<j then
           sort(l,j);
         if i<r then
           sort(i,r);
      end;
function find(x:longint):boolean;
var mo,now:longint;
begin
mo:=x mod 999983;
if hash[mo]=0 then
   begin
   inc(total);
   lian[total,1]:=x div 999983;
   hash[mo]:=total;
   exit(true);
   end
else begin
     now:=hash[mo];
     if int64(lian[now,1])*int64(999983)+mo=int64(x) then
       exit(false);
     while lian[now,2]<>0 do
       begin
       now:=lian[now,2];
       if int64(lian[now,1])*int64(999983)+mo=int64(x) then
          exit(false);
       end;
     inc(total);
     if total>1200000 then
      ttt:=1;
     lian[now,2]:=total;
     lian[total,1]:=x div 999983;
     exit(true);
     end;
end;
procedure extract;
begin
heap[1]:=heap[tot]; heap[tot]:=0;
dec(tot);
end;
procedure down(x:longint);
var t1,t2,pnum,tmp,q:longint;
begin
q:=x;
while (q*2<=tot)do
 begin
 t1:=heap[q*2];
 if q*2+1<=tot then t2:=heap[q*2+1] else t2:=maxlongint;
 if t1<t2 then pnum:=0 else pnum:=1;
 if heap[q]>heap[q*2+pnum] then
    begin
    tmp:=heap[q]; heap[q]:=heap[q*2+pnum]; heap[q*2+pnum]:=tmp;
    q:=q*2+pnum;
    end
 else
    break;
 end;
end;
procedure up(x:longint);
var q,tmp:longint;
begin
q:=x;
while x div 2>=1 do
 begin
 if heap[q]<heap[q div 2] then
    begin
    tmp:=heap[q]; heap[q]:=heap[q div 2]; heap[q div 2]:=tmp;
    q:=q div 2;
    end
 else
    break;
 end;
end;
begin
assign(input,'humble.in');
reset(input);
assign(output,'humble.out');
rewrite(output);
readln(k,n);
for i:=1 to k do read(p[i]); //prime;
sort(1,k);
tot:=1; heap[1]:=1;
done:=-1;
while (tot>0)and(done<n) do
  begin
   num:=heap[1];
   res:=num;
   inc(done);
   extract;
   down(1);
  for i:=1 to k do
      begin
      if int64(num)*int64(p[i])>int64(maxlongint) then
      break;
      t:=num*p[i];
      if find(t) then
         begin
         inc(tot);
         heap[tot]:=t;
         up(tot);
         end;
      end;
  ttt:=0;

  end;
writeln(res);
//while true do ttt:=0;
close(input);
close(output);
end.