牛人帮忙看一下

program jason;

Var

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

i,n,t,s,g:longint;

procedure SITF(l,m:longint);

var

k,j:integer;

begin

k:=l;

j:=2*k;

t:=a[k];

whileja[j+1] then

j:=j+1;

if t>a[k] then

begin

a[k]:=a[j];

k:=j;

j:=2*j;

end;

else break;

end;

a[k]:=t;

end.

begin

readln(n);

for i:=1 to n do

read(a[i]);

for i:=n div 2 downto 1 do

SITF(i,n);

s:=0;

g:=n;

while g>1 do

begin

i:=2;

if (i+1a)

then i:=i+1;

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

s:=s+a[i];

SITF(i,g);

a[1]:=a[g];

g:=g-1;

SITF(1,g);

end;

writeln(s);

end.

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

同样的程序,靠!!!怎么回事??????????????

program eat(input,output);

type

arr=array[1..10000] of longint;

var

mina,minb,sum:longint;

m,n,i:integer;

a:arr;

procedure init;

var

i:integer;

begin

fillchar(a,sizeof(a),0);

sum:=0;

readln(n);

m:=n;

for i:=1 to n do

read(a[i]);

end;

procedure milk(var a:arr;n,i:integer);

var

t,j:longint;

begin

t:=a[i];

j:=2*i;

while ja[j] then

begin a[i]:=a[j];i:=j;j:=2*i;end

else break;

end;

a[i]:=t;

end;

function min:longint;

begin

min:=a[1];

a[1]:=a[n];

n:=n-1;

milk(a,n,1);

end;

begin

init;

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

milk(a,n,i);

for i:=1 to m-1 do

begin

mina:=min;

minb:=min;

n:=n+1;

a[n]:=mina+minb;

milk(a,n,1);

sum:=sum+minb+mina;

end;

write(sum);

end.

郁闷掉，一样的程序……

Tiger 的结果：

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

Dolphin 的结果：

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

好像不是很难.........

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

var

i,j,k,n,m,v:longint;

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

procedure pai(l,r:longint);

var

i,j,k,mid:longint;

begin

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

i:=l;

j:=r;

repeat

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

if ij;

if l

堆排

快排+二分查找即可。

有些慢。

怎么还敢贴程序。

我郁闷啊,排序,然后加最小的,错了嘛?用的快排..为什么会错!!!!!!!!!!!!!就10分....- -|||郁闷啊~谁给解释下?DP测试

program zhangji;

type

arr=array[1..10000] of longint;

var a:arr;

i,j,k,l,m1,m2,n:longint;

procedure f(a:arr;x:longint);

var

jj,b:LONGINT;

begin

b:=maxlongint;

for jj:=1 to x do

if a[jj]

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

基本思路:

（１）快排g数组；

（２）得：每次要合并的堆子都是数组前两堆(=g[i]+g)....

（３）再把［合并得到的堆子］排进数组　　　　

就这样重复（n-1）次＝AC

↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓var

n,i,q,step,answer:longint;

g:array[1..10001]of longint;(记录每个堆子的重)

ans:array[1..10000]of longint;(记录每次合并的体力消耗)

procedure kuaipai(head,tail:longint);

var

x,y,mid,step:longint;

begin

x:=head;

y:=tail;

mid:=g[(x+y) div 2];

repeat

while g[x]mid do dec(y);

if xy;

if xhead then kuaipai(head,y);

end;

begin

readln(n);

fillchar(g,sizeof(g),0);

for i:=1 to n do

read(g[i]);

kuaipai(1,n);

for i:=1 to (n-1) do

begin

ans[i]:=g[i]+g;

g:=g[i]+g;

q:=i+1;

while (g[q]>g[q+1])and(q+1

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

不是吧！

队列O(n)，0ms

什么系堆排?(我系菜鸟,多多指教)

靠，无奈了，把integer改成longint就AC了。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

第3050个ac的，一次ac，纪念一下。

其实这道题目可以用两个队列的O（n）的算法。

a是原始队列，b是每次合并后的新的果子的队列，每次合并只需要比较a的前两个和b的前两个和a、b的第一个的和的最小值，进b队。当然a队开始是有序的

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

哈哈，第3000个AC的，纪念一下