合并果子 （codevs 1063） 题解

【问题描述】

    在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。

    每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。

    因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。

    例如有3种果子，数目依次为1，2，9。可以先将1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。

【样例输入】

     3 
    1 2 9

【样例输出】

    15

【解题思路】

     本题为NOIP2004提高组第二题，有两种方法可以解答。一个是贪心+堆，另一个是双排序队列。

     先来说说贪心+堆。

     首先，建一个小根堆，这样就保证根为最小的，取出根并维护小根堆，再取出根并维护小根堆，这样就得到了我们需要的结果，把结果插入堆中并维护，反复这个操作n-1次即可。详见代码。

    然后是队列。

    首先将果子排序，构成一个序列，将最前面的两堆果子取出，放入另一个队列，接下来，就只要判断之后应该取哪两堆，要么取最先的队列中的前两个，要么取新的队列中的前两个，要么取两个队列最前面的一个，然后再放到新的队列中，这样就能保证新的队列必是一个排序好的队列。将新的队列中的每个数加起来便是结果。

【代码实现】

var a:array[0..10000] of longint;
    i,n,k,ans,n1:longint;
procedure swap(var a,b:longint);
var y:longint;
begin
 y:=a;a:=b;b:=y;
end;
procedure sift(i,m:longint);
var k:longint;
begin
 a[0]:=a[i];
 k:=2*i;
 while k<=m do
  begin
   if (k<m)and(a[k]<a[k+1]) then
    inc(k);
   if a[0]<a[k] then
    begin
     a[i]:=a[k];
     i:=k;
     k:=i*2;
    end
   else
    k:=m+1;
  end;
 a[i]:=a[0];
end;
procedure heapsort;
var j:longint;
begin
 for j:=n div 2 downto 1 do
  sift(j,n);
 for j:=n downto 2 do
  begin
   swap(a[1],a[j]);
   sift(1,j-1);
  end;
end;
function deletemin:longint;
var i,pos:longint;
begin
 i:=1;
 deletemin:=a[1];
 a[1]:=a[n1];
 dec(n1);
 while 2*i<=n1 do
  begin
   pos:=2*i;
   if (pos<n1)and(a[pos+1]<a[pos]) then
    inc(pos);
   if a[i]>a[pos] then
    begin
     swap(a[i],a[pos]);
     i:=pos;
    end
   else
    break;
  end;
end;
procedure insert(k:longint);
var i:longint;
begin
 inc(n1);
 a[n1]:=k;
 i:=n1;
 while (i div 2>0)and(a[i div 2]>k) do
  begin
   swap(a[i],a[i div 2]);
   i:=i div 2;
  end;
end;
begin
 readln(n);
 for i:=1 to n do
  read(a[i]);
 heapsort;
 n1:=n;
 for i:=1 to n-1 do
  begin
   k:=deletemin;
   k:=k+deletemin;//取出根并维护
   ans:=ans+k;
   insert(k);//插入结果并维护
  end;
 writeln(ans);
end.

var old,new:array[0..10000] of longint;
    i,n,fo,fn,rn,ans:longint;
procedure swap(var i,j:longint);
var y:longint;
begin
 y:=i;i:=j;j:=y;
end;
procedure sift(i,m:longint);
var k:longint;
begin
 old[0]:=old[i];
 k:=2*i;
 while k<=m do
  begin
   if (k<m)and(old[k]<old[k+1]) then
    inc(k);
   if old[0]<old[k] then
    begin
     old[i]:=old[k];
     i:=k;
     k:=2*i;
    end
   else
    k:=m+1;
  end;
 old[i]:=old[0];
end;
procedure heapsort;
var j:longint;
begin
 for j:=n div 2 downto 1 do
  sift(j,n);
 for j:=n downto 2 do
  begin
   swap(old[1],old[j]);
   sift(1,j-1);
  end;
end;
begin
 readln(n);
 for i:=1 to n do
  read(old[i]);
 heapsort;//这个排序可以是堆排，二叉排序树，快排等等，因为我今天复习到堆，就用堆排了
 fo:=3;
 new[1]:=old[1]+old[2];
 ans:=new[1];
 fn:=1;
 rn:=1;
 repeat
  if (old[fo+1]<>0)and(old[fo+1]<new[fn])then
   begin
    inc(rn);
    new[rn]:=old[fo]+old[fo+1];
    ans:=ans+new[rn];
    inc(fo,2);
   end
   else
    if (new[fn+1]<>0)and(new[fn+1]<old[fo]) then
     begin
      inc(rn);
      new[rn]:=new[fn]+new[fn+1];
      ans:=ans+new[rn];
      inc(fn,2);
     end
    else
     if (old[fo]=0)and(new[fn+1]<>0) then
      begin
       inc(rn);
       new[rn]:=new[fn]+new[fn+1];
       ans:=ans+new[rn];
       inc(fn,2);
      end
     else
      begin
       inc(rn);
       new[rn]:=new[fn]+old[fo];
       ans:=ans+new[rn];
       inc(fo);
       inc(fn);
      end;
 until (old[fo+1]=0)and(new[fn+1]=0);
 writeln(ans);
end.