编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

编译通过...

├ 测试数据 01：答案正确... 291ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：运行超时...

├ 测试数据 06：答案正确... 9ms

├ 测试数据 07：运行超时...

├ 测试数据 08：运行超时...

├ 测试数据 09：答案正确... 166ms

├ 测试数据 10：答案正确... 306ms

├ 测试数据 01：答案正确... 416ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 41ms

├ 测试数据 07：答案正确... 244ms

├ 测试数据 08：答案正确... 416ms

├ 测试数据 09：答案正确... 244ms

├ 测试数据 10：答案正确... 416ms

差距怎么这么大啊

支持tiger

program vijos_1097;

var a:array[1..10001]of longint;

cc,n,i,j,l:longint;

procedure qsort(l,r:longint);

var x,y,i,j:longint;

begin

i:=l;

j:=r;

x:=a[random(r-l+1)+l];

repeat

while a[i]x do dec(j);

if not(i>j) then

begin

y:=a[i];

a[i]:=a[j];

a[j]:=y;

inc(i);

dec(j);

end;

until i>j;

if l

program ex1;

var

n,a,b,c,d:longint;

arr:array[1..200001] of longint;

s:int64;

procedure quicksort(l,r:longint);

var

x,y,i,j:longint;

begin

i:=l; j:=r; x:=arr[(l+r) div 2];

while i

编译通过...

├ 测试数据 01：运行超时...

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 197ms

├ 测试数据 08：运行超时...

├ 测试数据 09：运行超时...

├ 测试数据 10：答案正确... 291ms

我的AC率~~~

编译通过...

├ 测试数据 01：答案正确... 291ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 9ms

├ 测试数据 07：答案正确... 166ms

├ 测试数据 08：答案正确... 322ms

├ 测试数据 09：答案正确... 166ms

├ 测试数据 10：答案正确... 306ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：1260ms

编译通过...

├ 测试数据 01：答案正确... 369ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 41ms

├ 测试数据 07：答案正确... 181ms

├ 测试数据 08：答案正确... 353ms

├ 测试数据 09：答案正确... 181ms

├ 测试数据 10：答案正确... 369ms

第二次：

编译通过...

├ 测试数据 01：运行超时...

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 181ms

├ 测试数据 08：答案正确... 353ms

├ 测试数据 09：答案正确... 197ms

├ 测试数据 10：答案正确... 291ms

---|---|---|---|---|---|---|---|-

Unaccepted 有效得分：90 有效耗时：1022ms

同一个Lora Temper，同一个程序，两回的结果：

编译通过...

├ 测试数据 01：答案正确... 88ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 556ms

├ 测试数据 07：答案正确... 197ms

├ 测试数据 08：答案正确... 150ms

├ 测试数据 09：答案正确... 166ms

├ 测试数据 10：运行超时...

---|---|---|---|---|---|---|---|-

Unaccepted 有效得分：90 有效耗时：1157ms

编译通过...

├ 测试数据 01：答案正确... 72ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 212ms

├ 测试数据 08：答案正确... 119ms

├ 测试数据 09：答案正确... 197ms

├ 测试数据 10：答案正确... 103ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：703ms

我真服气……

program hebing;

var

a,b:array[1..40000]of longint;

s,n,i,j,k,temp:longint;

function min(o,p,q:longint):longint;

begin

if (o

这道题目有一种很简单达到O(n)复杂度的做法，考虑到每次合并两个结点以后，得到的新结点大小是递增的，于是可以维护两个队列，一个是原队列A，一个是新加入的队列B。每次就一定是在A或（和）B的首部取数，在B的尾部插入。

另外因为a[i]很小只有20000，所以可以使用基数排序，使得排序时间复杂度成为O(20000)。

这样整体的时间复杂度就是O(n)。

详细的结题报告和代码请看http://yinyifan.com/blog/2008/10/noip2004\_fruit\_report

编译通过...

├ 测试数据 01：答案正确... 400ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 25ms

├ 测试数据 07：答案正确... 228ms

├ 测试数据 08：答案正确... 400ms

├ 测试数据 09：答案正确... 244ms

├ 测试数据 10：答案正确... 400ms

---|---|---|---|---|---|---|---|-

辛苦啊,终于搞定

堆排+双队列=>AC

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

var

h1,h2,t2:longint;

n,i:integer;

a,b:array[0..10000]of longint;

procedure init;

var

i,t:integer;

procedure heap(i,m:integer);

var

x:integer;

begin

while i*2a[i]) and (ia[i div 2] then

begin

x:=a[i];

a[i]:=a[i div 2];

a[i div 2]:=x;

end

else break;

end;

end;

begin

readln(n);

for i:=1 to n do read(a[i]);

for i:=(n div 2) downto 1 do heap(i,n);

for i:=n downto 2 do

begin

t:=a[i];

a[i]:=a[1];

a[1]:=t;

heap(1,i-1);

end;

end;

procedure main;

var

x,y:longint;

i:integer;

ans:qword;

function find(q,w:integer):longint;

begin

if q>n then

begin

inc(h2);

exit(b[w]);

end;

if w>t2 then

begin

inc(h1);

exit(a[q]);

end;

if a[q]>b[w] then

begin

inc(h2);

exit(b[w]);

end

else

begin

inc(h1);

exit(a[q]);

end;

end;

begin

fillchar(b,sizeof(b),0);

ans:=0;

t2:=1;

h1:=2;

h2:=1;

b[1]:=a[1];

for i:=2 to n do

begin

x:=find(h1,h2);

y:=find(h1,h2);

inc(t2);

b[t2]:=x+y;

end;

for i:=2 to n do ans:=ans+b[i];

writeln(ans);

end;

begin

init;

main;

end.

用堆排很快

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

#include

int heap[100001],size(0) ;

int left(int p)

{return p1]>num )

heap[p]=heap[p>>=1];

heap[p]=num;

}

void work(int p)

{int l=left(p),r=right(p), min;

if(l

├ 测试数据 01：答案正确... 275ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 88ms

├ 测试数据 08：答案正确... 228ms

├ 测试数据 09：答案正确... 134ms

├ 测试数据 10：答案正确... 212ms

VIJOS评测机的确猛,在本机有3个点没过这里过了

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

├ 测试数据 01：答案正确... 697ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 25ms

├ 测试数据 06：答案正确... 88ms

├ 测试数据 07：答案正确... 619ms

├ 测试数据 08：答案正确... 744ms

├ 测试数据 09：答案正确... 588ms

├ 测试数据 10：答案正确... 650ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：3411ms

哎。。。不会快排 我用的冒泡。。。

编译通过...

├ 测试数据 01：答案正确... 994ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：994ms

汗！！！- -|||

暴汗..

数组开小了..

4次才AC.....

双队列..

0MS AC..

切记数组要开到30000+

编译通过...

├ 测试数据 01：答案正确... 666ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 103ms

├ 测试数据 07：答案正确... 556ms

├ 测试数据 08：答案正确... 697ms

├ 测试数据 09：答案正确... 462ms

├ 测试数据 10：答案正确... 712ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：3196ms

看谁有我慢

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

每次合并找最小的两堆果子a[1]，较大的一堆(a[2]或a[3])赋值为其和，累加。对a[2]或a[3]排序后，对a[1]排序。循环n-1次。

program p1097;

var a:array [1..10000] of dword;

s,k,n,temp:dword;

procedure heap(nn,ii:dword);

var i,j,x:dword;

begin

i:=ii;

x:=a[i];

j:=2*i;

while ja[j] then begin

a[i]:=a[j];

i:=j;

j:=2*i

end

else j:=nn+1

end;

a[i]:=x

end;

begin

read(n);

for k:=1 to n do read(a[k]);

s:=0;

for k:=n div 2 downto 1 do

heap(n,k);

for k:=n downto 2 do

begin

temp:=2;

if (k>2)and(a[3]

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

我靠可恶的双队列... 一个大于号写成大等了 超时N次 窝火

Program Fruit;

Const

Maxn = 30001;

Inf = 'Fruit.in';

Var

G, Z: Array [0..Maxn] Of Longint;

i, j, k, n: Integer;

Ans: Longint;

Procedure QuickSort(l, r: Integer);

Var

i, j: Integer;

x, y: Longint;

Begin

i := l;

j := r;

x := G[(l + r) Div 2];

Repeat

While G[i] < x Do Inc(i);

While G[j] > x Do Dec(j);

If i j;

If l < j Then QuickSort(l, j);

If i < r Then QuickSort(i, r);

End;

Begin

FillChar(G, SizeOf(G), 126);

FillChar(Z, SizeOf(Z), 126);

ReadLn(n);

For i:= 1 To n Do Read(G[i]);

If n 1 Then Begin

QuickSort(1, n);

k := 1;

i := 1;

j := 0;

Repeat

If (G[k + 1]

编译通过...

├ 测试数据 01：答案正确... 447ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：运行超时|无输出...

├ 测试数据 06：运行超时|无输出...

├ 测试数据 07：运行超时|无输出...

├ 测试数据 08：运行超时|无输出...

├ 测试数据 09：答案正确... 322ms

├ 测试数据 10：运行超时|无输出...

---|---|---|---|---|---|---|---|-

Unaccepted 有效得分：50 有效耗时：769ms