编译不通过……交到rqnoj上AC……orz……

插排不熟

program p1097;

var n,w,i:longint;

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

procedure init;

var i:longint;

begin

w:=0;

readln(n);

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

end;

procedure qsort(l,r:longint);

var i,j,t,tmp:longint;

begin

i:=l; j:=r; t:=a[i];

repeat

while (a[j]>=t) and (j>i) do dec(j);

if j>i then begin tmp:=a[i]; a[i]:=a[j]; a[j]:=tmp; end;

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

if j>i then begin tmp:=a[i]; a[i]:=a[j]; a[j]:=tmp; end;

until i=j;

a[i]:=t;

inc(j); dec(i);

if l

各位大牛们，请帮忙看看俺哪里错了！谢谢

编译通过...

├ 测试数据 01：答案错误...　├ 标准行输出

　├ 错误行输出

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

├ 测试数据 03：答案错误...　├ 标准行输出

　├ 错误行输出

├ 测试数据 04：答案错误...程序输出比正确答案长

├ 测试数据 05：答案错误...　├ 标准行输出

　├ 错误行输出

├ 测试数据 06：答案错误...　├ 标准行输出

　├ 错误行输出

├ 测试数据 07：答案错误...　├ 标准行输出

　├ 错误行输出

├ 测试数据 08：答案错误...　├ 标准行输出

　├ 错误行输出

├ 测试数据 09：答案错误...　├ 标准行输出

　├ 错误行输出

├ 测试数据 10：答案错误...　├ 标准行输出

　├ 错误行输出

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

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

program popkart;

var

i,j,l,m,n,s,r,t:longint;

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

begin

readln(n);

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

for i:=1 to n do begin

for j:=1 to i-1 do begin

if a[i]

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

同一个程序交两遍的结果= =

编译通过...

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

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

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

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

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

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

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

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

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

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

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

编译通过...

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

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

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

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

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

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

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

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

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

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

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

我是用快排...为什么会错...麻烦各位大大帮助一下...前面的过程是快排 就不用看了...这应该没有问题...主要是程序主要部分那个累加体力的时候...很奇特啊很奇特啊...除了第二个数据对了以外...全错...

program ex1;

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

r,l,i,n,m:longint;

procedure pai(l,r:integer);

var q,i,j,mid:Integer;

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

#include

#define parent(i) i/2

#define left(i) i*2

#define right(i) i*2+1

using namespace std;

int v[10002],n;

unsigned long int ans=0;

void heapify(int x){

int i,k;

if(left(x)

纪念我的第一百次提交奉献给了这道水题！

贪心+堆优化秒掉！

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

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

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

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

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

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

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

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

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

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

用链表就可以,适合懒得用双队的,疯了,狂测不行,发现指针忘用longint...

就是秒不掉而已

program guozi;

type

point=^node;

node=record

data:longint;

link:point;

end;

var

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

tot,t:longint;

i,j,n:integer;

head,next,last,hate:point;

procedure qsort(l,r:integer);

var i,j,x:longint;

begin

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

repeat

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

if ij;

if il then qsort(l,j);

end;

begin

assign(input,'fruit.in');

assign(output,'fruit.out');

reset(input);

rewrite(output);

readln(n);

for i:=1 to n do

read(a[i]);

qsort(1,n);

//for i:=1 to n do

//write(a[i],' ');

//writeln;

new(head);

head^.data:=a[1];

last:=head;

for i:=2 to n do

begin

new(next);

next^.data:=a[i];

last^.link:=next;

last:=next;

end;

last^.link:=nil;

tot:=0;

while head^.linknil do

begin

next:=head^.link;

next^.data:=head^.data+next^.data;

tot:=tot+next^.data;

dispose(head);

head:=next;

if head^.linknil then

begin

while (next^.linknil)and(next^.link^.data

二叉堆才是王道……

program fruit;

var

n,k,i,t,ans,m: longint;

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

procedure heapsort(l,m:longint);

var

i,j,t: longint;

begin

i:=l; j:=i shl 1; t:=a[i];

while j

var n,i:integer;

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

s:longint;

ok:boolean;

procedure bj(a,b:longint);

var t:longint;

begin

if a>b then begin

t:=a;a:=b;b:=t;end;

end;

procedure slow(n:integer);

var i,j:integer;

begin

for i:=1 to n-1 do

for j:=1 to i-1 do

bj(a[i],a);

end;

procedure cheat(var n:integer);

var i,j,k:integer;

begin

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

s:=s+a[1];

for i:=2 to n-1 do a[i]:=a;

dec(n);

for i:=1 to n-1 do if (a>=a[1]) then break;

if i>1 then begin

k:=a[1];for j:=1 to i-1 do a[j]:=a[j+1];a[i]:=k;end;

end;

begin

ok:=false;

readln(n);

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

readln;

s:=0;

slow(n);

repeat

if (n>2)and(ok) then cheat(n) else bj(a[1],a[2]);

ok:=true;

until n=1;

writeln(s+a[1]);

end.

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

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

j,i,n,k,t,x:integer;

total:longint;

begin

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

for i:=1 to n-1 do

for j:=i+1 to n do

if a[i]2 do

begin

k:=n-2;

x:=a[k+2]+a[k+1];

total:=total+x;

while k>0 do

if a[k]

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

&n=11

这题目对不对啊，数组竟要开到比10000大啊！

老是这种问题浪费我时间啊！

快排加插入...

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

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

procedure gg(l,r:longint);

var i,j,m,sw:longint;

begin

i:=l;j:=r;

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

while i

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

猥琐！

数据范围差的也太大了！

说是10000以内，我数组开到16000还出错！！！

害得我交了好多次！！！

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

编译通过...

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

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

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

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

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

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

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

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

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

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

so h

最傻的做法。。。。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

var

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

n,m1,m2,i,j:integer;

min1,min2,li,he:longint;

begin

readln(n);

for i:=1 to n do

read(a[i]);

li:=0;

while n>1 do

begin

{if n=1 then

begin

li:=li+a[1];

break;

end;}

he:=0;

min1:=a[1];

m1:=1;

for i:=1 to n do

if a[i]