这道题最好使用堆的，可以秒，双队列也行。

快排+插排就慢一点。

太坚强了

快排5点超时

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

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

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

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

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

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

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

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

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

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

插排1点超时

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

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

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

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

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

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

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

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

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

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

快排+插排终于搞定了！

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

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

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

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

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

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

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

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

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

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

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

终于秒了！

秒杀好爽！

搞懂堆排了！

此题还是堆排好！

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

双队列

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

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

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

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

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

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

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

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

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

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

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

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

秒了

var

i,n:integer;

min:longint;

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

procedure doit;

var

i,j,l:integer;

x,y,z:longint;

begin

min:=0;

i:=1; j:=1;

l:=0;

repeat

inc(l);

x:=a[i]+a;

y:=a[i]+b[j];

z:=b[j]+b[j+1];

if (x

var

n,k,l,i,j,min,x,y,z:longint;

a:array[0..20000] of longint;

b:array[0..20000] of longint;

procedure qsort(l,r:longint);

var

i,j,mid,k:longint;

begin

i:=l;

j:=r;

mid:=a[(l+r) div 2];

repeat

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

if ij;

if i

终于 我没救了

{} Program Vijos_P1097;

{} Var

{} a: Array [1..10000] Of dWord;

{} s, t: dWord; i, n: Word;

{} Procedure Heap(u, d: Word);

{} Var l: Word;

{} Begin

{} t:=a; l:=u Shl 1;

{} While l

这题用贪心就可解决。每次选最小的两堆合并。不用任何优化都可过。

......我打错一个变量，交了4次才过......

只能说我太水

var

n,i:longint;

sum:qword;

a:array[-1..10001] of qword;

procedure sqort(x,y:longint);

var

i,j,k:longint;

begin

i:=x;

j:=y;

k:=a[(i+j) div 2];

repeat

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

if ij;

if ix then sqort(x,j);

end;

begin

readln(n);

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

sqort(1,n);

for i:=2 to n-1 do begin

a[i]:=a+a[i];

inc(sum,a[i]);

end;

inc(a[n],a[n-1]);

writeln(a[n]+sum);

end.

各位大牛，帮我检查一下哪里错了？？？

我们坚信快排，我们坚持插排！

双队列

一个比较显然的结论是队列b会比a晚合并完,所以a合并完后要单独合并b...WA了几次

核心代码

for i:=1 to 2 do begin

if (a[p1]

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

program su_he(input,output);

var

s,n,i:longint;

a:array[1..100000]of longint;

max1,max2:longint;

procedure hebing(n:longint);

var

i,j,k:longint;

begin

if n=1 then exit else

begin

max1:=maxlongint;max2:=maxlongint;

for i:=1 to n do

if a[i]

var

a :array[0..20000]of longint;

i :longint;

n,ans :longint;

procedure qsort(l,r:longint);

var

i,j,x,y :longint;

begin

i:=l;j:=r;

x:=a[(i+j)div 2];

repeat

while a[i]>x do inc(i);

while x>a[j] 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

靠，竟然有那么多人是秒杀……我太弱了

秒杀~~~~~ 我是沙茶~~~~ 此代码谨献给研究者 抄袭者自助~~

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

n,i,j,k,l,m,ans,min:longint;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

procedure qsort(l,r:longint);

var i,j,mid,temp:longint;

begin

i:=l;j:=r;

mid:=a[(i+j) shr 1];

repeat

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

if ij;

if ia[i]+b[j]) then

begin

min:=a[i]+b[j];k:=3;

end;

if k=1 then inc(i,2);

if k=2 then inc(j,2);

if k=3 then begin

inc(i);inc(j);

end;

inc(m);

b[m]:=min;

dec(ans,min);

end;

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

begin

readln(n);

for i:=1 to n do

read(a[i]);

qsort(1,n);

ans:=0; i:=1; j:=1; k:=0;

for l:=1 to n-1 do

begin

min:=maxlongint;

minx;

end;

writeln(ans);

end.

const

maxn=30000;

var

a,b:array[1..maxn+2] of longint;

n,i,ans:longint;

procedure quicksort(l,r:longint);

var i,j,mid,tem:longint;

begin

i:=l;j:=r; mid:=a[(l+r) div 2];

repeat

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

if ij;

if l

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

用堆优化的结果

貌似只操作n-1次........队列！！！！！！吐了....

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

编译通过...

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

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

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

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

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

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

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

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

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

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

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