编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

这是用堆排写的后果，还好一次AC了

我采用了多关键字排序，这样就解决了编号小的在前面的问题

堆栈溢出错误大概是 快排写错了

if k=0 then halt;

不能用write（‘’）；

type

jilu=record

e,f,g:int64;

end;

var

a:array[0..100000]of jilu;

c:array[0..9]of int64;

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

procedure qsort(l,r:longint);

var

i,j:longint;

temp,mid:jilu;

begin

i:=l;

j:=r;

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

repeat

while (a[i].e>mid.e)or(a[i].e=mid.e)and(a[i].f

哪个牛人发个答案啊!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

佳佳 是 刘汝佳么....

如果是写堆排序的话，

主干部分那叫一个复杂啊
承受不了又上交两遍
本题已经上交了六次有余

procedure sort(l,r:longint);

var i,j,t,q: longint;

begin

i:=l; j:=i*2; t:=w[i]; q:=d[i];

while j

program jjmagic;

type

jl=record

bh:longint;

w:longint;

end;

var

i,j,k,n:longint;

x:array[0..100000]of jl;

e:array[1..10]of longint;

procedure qsort1(l,r: longint);

var

i,j,xx,y,yy:longint;

begin

i:=l;

j:=r;

xx:=x[(l+r) div 2].w;

yy:=x[(l+r) div 2].bh;

repeat

while (x[i].w>xx) or ((x[i].w=xx)and(x[i].bhj) then

begin

y:=x[i].w;

x[i].w:=x[j].w;

x[j].w:=y;

y:=x[i].bh;

x[i].bh:=x[j].bh;

x[j].bh:=y;

inc(i);

dec(j);

end;

until i>j;

if l

看完题目 我晕了

楼下的楼下 。。你是CIN花了很多时间。不关归并的事。

审题不认真吃亏啊。。。。。。两次快排都排反了。。。。。。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

归并用了这么长时间……

#include

using namespace std;

long a[50010],c[50010],s[50010];

void sort(long l,long r)

{

if (l>=r) return;

long mid=(l+r)/2;

sort(l,mid);sort(mid+1,r);

long ll=l,rr=mid+1;

while (lle[i];

for (long i=1;i>a[i];s[i]=i;}

sort(1,n);

for (long i=1;i

编译通过...

├ 测试数据 01：运行时错误...| 错误号: 202 | 堆栈溢出错

├ 测试数据 02：运行时错误...| 错误号: 202 | 堆栈溢出错

├ 测试数据 03：运行时错误...| 错误号: 202 | 堆栈溢出错

├ 测试数据 04：运行时错误...| 错误号: 202 | 堆栈溢出错

├ 测试数据 05：运行时错误...| 错误号: 202 | 堆栈溢出错

├ 测试数据 06：运行时错误...| 错误号: 202 | 堆栈溢出错

├ 测试数据 07：运行时错误...| 错误号: 202 | 堆栈溢出错

├ 测试数据 08：运行时错误...| 错误号: 202 | 堆栈溢出错

├ 测试数据 09：运行时错误...| 错误号: 202 | 堆栈溢出错

├ 测试数据 10：运行时错误...| 错误号: 202 | 堆栈溢出错

namespace是c++的

第一次用c++ 弄掉了这水题

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

怎么重新看记录变成超时了，但Flag依然是Accepted

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

第一次用C的，但是忘记删去一些东西，No Compiled 了好几次

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

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

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

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

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

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

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

　├ 错误行输出

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

　├ 错误行输出

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

　├ 错误行输出

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

　├ 错误行输出

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

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

#include

using namespace std;

const unsigned int N=50000;

long int mins=-999999;

int value[11];

int w[N+1];

int a[N+2];

void qs (int low,int high)

{

int i=low,j=high,value=w[low],v2=a[low];

if (loww[i];a[i]=i;}

qs(1,n);

a[50001]=50001;

for (i=1;i

我快排56MS？

两次快排。简简单单就是题目难看了点。打赌作者是文科。

提示：

if k=0 then

write(' ');

题目里出现了序号和编号。实际上编号用不到，就是i，序号在读入的时候赋值好，两次快排都要用进去。

vijos是块海绵，用力挤挤总会有水挤出来的……

秒杀的说。不知道下面的不秒杀的人怎么做的。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

娘的：：

编译通过...

├ 测试数据 01：运行时错误...|错误号: 1

├ 测试数据 02：运行时错误...|错误号: 4

├ 测试数据 03：运行时错误...|错误号: 37

├ 测试数据 04：运行时错误...|错误号: 12

├ 测试数据 05：运行时错误...|错误号: 8

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

├ 测试数据 07：运行时错误...|错误号: 667

├ 测试数据 08：运行时错误...|错误号: 778

├ 测试数据 09：运行时错误...|错误号: 889

├ 测试数据 10：运行时错误...|错误号: 1000

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

倒霉死了，第一次忘了判断，如果两个数值一样，要输出小的那一个！

结果：

编译通过...

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

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

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

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

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

　├ 错误行输出

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

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

　├ 错误行输出

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

　├ 错误行输出

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

　├ 错误行输出

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

　├ 错误行输出

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

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

倒霉死了，大家一定要注意哦！

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

两次quicksort 一次AC 第55题