可恶，downto打成to竟然没发现。。。

#include

using namespace std;

#define MAXNN 200000000

int n;

int a[10001],b[10001];

int x=1,y=1,p=1;

int hard;

int order;

int MIN(int a1,int b1,int c1)

{

if(a1

首先我们将n堆果子按照果子数递增的顺序排成一个序列

a[1]‥a[n],a[n+1]=∞,a[n+2]=∞。

b序列设为空(b[1]=b[2]= ‥b[n]= ∞，p=0)。

从a序列和b序列的第一个元素开始寻找合并方案（x=1，y=1）。

每一次合并方案不外乎三种：

合并两个初始堆（a[x]+a[x+1]）；

一个初始堆与一个先前被合并的堆进行合并（a[x]+b[y]）；

两个先前被合并的堆进行合并（b[y]+b[y+1]）；

显然，本次合并耗费的体力值为

min=MIN{a[x]+a[x+1],a[x]+b[y],b[y]+b[y+1]}

b序列新增加一个权值为min的元素（p=p+1，b[p]=min），

min累计入最小的体力耗费值ans（ans=ans+min）

并按照下述方法移动指针x、y

如果采纳第一种合并方案，则a序列的指针x=x+2；

如果采纳第二种合并方案，则a序列的指针x=x+1，b序列的指针y=y+1；

如果采纳第三种合并方案，则b序列的指针y=y+2。

由于a序列和b序列是递增的，因此，上述指针移动的方法可以保证每次总是选择权值最小的两个节点进行合并。进行了n-1次合并后得出的ans即为问题的解。

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

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

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

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

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

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

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

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

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

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

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

数组 快排……

再 链表 贪心……

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

program p1097;

const

maxn=10000;

var

n,i:integer;

a:array[0..maxn+1] of longint;

ans:qword;

procedure sort1(l,r:integer);

var

i,j:integer;

x,g:longint;

begin

i:=l;j:=r;x:=a[(l+r) shr 1];

repeat

while a[i]

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

program p1097;

const

maxn=10000;

var

n,i:integer;

a:array[0..maxn+1] of longint;

ans:qword;

procedure sort1(l,r:integer);

var

i,j:integer;

x,g:longint;

begin

i:=l;j:=r;x:=a[(l+r) shr 1];

repeat

while a[i]

用最小堆全0MS

。。。。。。。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

各位大哥,小弟想找一个好师傅来教教我.有意者请++++++++++++++++我的Q:714332048,谢谢

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

program p1097;

var

n,i,k,t,r,l,j:longint;

sum:int64;

a:array [1..20000] of int64;

begin

readln(n);

for i:=1 to n do begin

read(j);

a[i]:=j;

end;

l:=n;

sum:=0;

while n>1 do begin

j:=1;

while a[j]=0 do inc(j);

t:=j;

inc(j);

while a[j]=0 do inc(j);

r:=j;

if a[t]>a[r] then begin

t:=t xor r;

r:=t xor r;

t:=t xor r;

end;

for i:=j+1 to n do begin

if (a[r]>a[i]) and (a[i]0) then r:=i;

if a[t]>a[r] then begin

t:=t xor r;

r:=t xor r;

t:=t xor r;

end;

end;

a[t]:=a[t]+a[r];

a[r]:=a[n];

dec(n);

sum:=sum+a[t];

end;

writeln(sum);

end.

疯狂的O(nlogn)，还蛮整齐的

编译通过...├ 测试数据 01：答案正确... 650ms├ 测试数据 02：答案正确... 0ms├ 测试数据 03：答案正确... 0ms├ 测试数据 04：答案正确... 0ms├ 测试数据 05：答案正确... 9ms├ 测试数据 06：答案正确... 88ms├ 测试数据 07：答案正确... 572ms├ 测试数据 08：答案正确... 650ms├ 测试数据 09：答案正确... 572ms├ 测试数据 10：答案正确... 650ms-------------------------Accepted 有效得分：100 有效耗时：3191ms极限通过。。。泪流满面

编译通过...

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

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

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

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

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

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

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

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

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

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

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

Unaccepted 有效得分：10 有效耗时：0ms

编译通过...

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

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

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

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

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

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

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

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

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

├ 测试数据 10：答案正确... 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

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

longint 过不了

QWORD才过。。。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

链表……什么效率……

编译通过...

├ 测试数据 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