编译通过...

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

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

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

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

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

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

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

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

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

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

终于ac,看了俩天O(10*k)算法,上数学课突然understand, 建议看zhymaoiing解题报告

谁讲讲O（10*K）算法啊

SPLAY SPLAY!

jefflepad跟我一开始错的一样，c是指把从a到b剪切之后的行数，所以应该先把a到b剪切出去

#include

#include

#define maxn 100000

long text[maxn+10],buffer[maxn+10],n,k;

int main()

{

long i,a,b,c,sz;

scanf("%ld%ld",&n,&k);

for(i=1;i

请教各位大牛

这个问题有点奇怪

用链表直接模拟全部出现如此奇怪结果

编译通过...

├ 测试数据 01：运行时错误...| 错误号: 216 | 存取非法

├ 测试数据 02：运行时错误...| 错误号: 216 | 存取非法

├ 测试数据 03：运行时错误...| 错误号: 216 | 存取非法

├ 测试数据 04：运行时错误...| 错误号: 216 | 存取非法

├ 测试数据 05：运行时错误...| 错误号: 216 | 存取非法

├ 测试数据 06：运行时错误...| 错误号: 216 | 存取非法

├ 测试数据 07：运行时错误...| 错误号: 216 | 存取非法

├ 测试数据 08：运行时错误...| 错误号: 216 | 存取非法

├ 测试数据 09：运行时错误...| 错误号: 216 | 存取非法

├ 测试数据 10：运行时错误...| 错误号: 216 | 存取非法

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

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

原因未知

我自己编了记住评测数据都不故障

用它提供的范例也不故障

程序如下

type point=^node;

node=record

int:longint;

next:point;

end;

var head,a,b,c,d,e,f:point;

i,j,l,m,n,k,fr,en,into:longint;

begin new(head);head^.int:=0;head^.next:=nil;

readln(n,k);

a:=head;

for i:=1 to n do

begin new(b);b^.int:=i;b^.next:=nil;a^.next:=b;a:=b;end;

for i:=1 to k do

begin readln(fr,en,into);

if into=0 then begin a:=head;for j:=1 to (fr-1) do a:=a^.next;{a待求前驱}

e:=a^.next;{e待求}

b:=e;for j:=1 to (en-fr) do b:=b^.next;{b待求}

f:=b^.next;{f待求后驱}

c:=head^.next;

head^.next:=e;

b^.next:=c;

a^.next:=f;

end

else begin a:=head;for j:=1 to (fr-1) do a:=a^.next;

e:=a^.next;

b:=e;for j:=1 to (en-fr) do b:=b^.next;

f:=b^.next;

c:=head;for j:=1 to into do c:=c^.next;

d:=c^.next;

c^.next:=e;

b^.next:=d;

a^.next:=f;

end;

end;

a:=head^.next;for i:=1 to 10 do

begin writeln(a^.int);

a:=a^.next;

end;

End.

O(10*k)是个好东西

{for j:=1 to 10 do

begin

k:=j;

for i:=m downto 1 do

if (k>=c[i]+1)and(kc[i]+r[i]-l[i]+1 then k:=k-(r[i]-l[i]+1);

if k>=l[i] then k:=k+r[i]-l[i]+1;

end;

writeln(k);

end;}

//orz j*

MOVE王道..靠!!

我同样的程序..要交两遍..

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

居然……小号过了大号居然没AC……一样的程序第一个点超时………………

人生不得志，十有八九…………

做3个ansistring，用256进制存每个数。

这样再过不了就是RP问题了。

感谢Minus Zero.Albert Thomas的算法启示。

src250/hitman47 在我的指点/帮助下过了...............

我在zhymaoiing大牛的题解下过了（思路基本一样，删了2行错误判定）......

关于解决此题过程总结成一句话:顶歇！（底歇的终极版）......

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

此题解对理解力要求很高，还是建议去看楼上zhymaoiing的吧，人家才是真大牛~

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

主思想：反推模拟

实现过程：

初始化，B数组中每个元素代表最后一轮中的数所在的位置，注意，是位置！！！！

那么恢复到初始时则即为解.

m downto 1 ---|---|a[j,1],a[j,2],a[j,3]

然后就开始处理，分3段：

在移动的范围内，

判定：(a[j,3]+1=b[i])

恢复执行：b[i]:=b[i]+a[j,1]-a[j,3]-1;

在左边，即比移动的小，判定：(a[j,2]+a[j,3]-a[j,1]+1=b[i]

移动：b[i]:=b[i]-a[j,2]+a[j,1]-1;

在右边，即比移动的小，判定：if (b[i]

让我顶歇 让我囧

10遍提交啊~~~~~

var i,j,k,l,m,n,p:longint;

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

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

begin

read(n,m);

for i:=m downto 1 do

begin

read(a,a,a);

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

end;

for i:=1 to 10 do

begin

p:=i;

for j:=1 to m do

if (a[j,3]

啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊

我快被它逼疯了！

强烈建议将这道迫害OIer大脑的题删掉

（疯癫中…………………………）

我受不了了......此题我足足困了3天终于AC了...

这题用字符串做可以吗？

program p1058;

var s,s1,s2,s3,s4:ansistring;

i,j,l,a,b,c,k,n:longint;

begin

readln(n,k);

s:='';

for i:=1 to n do

s:=s+chr(i+48);

l:=length(s);

for i:=1 to k do

begin

readln(a,b,c);

if c=0 then s1:=''

else s1:=copy(s,1,c);

s2:=copy(s,b+1,l-b);

s3:=copy(s,a,b-a+1);

s4:=copy(s,c+1,a-c-1);

s:=s1+s3+s4+s2;

end;

for i:=1 to 10 do

writeln(ord(s[i])-48);

end.

哪个大牛看下这个程序 为什么一个点也过不去 全部是答案错误？

用了MOVE..直接模拟..ac

move(p[a],s[1],(b-a+1)*4);

move(p,p[a],(n-b+1)*4);

move(p[c+1],s,(n-c)*4);

move(s[1],p[c+1],((b-a+1)+(n-c))*4);

对内存操作就是快

块状链表

编译通过...

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

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

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

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

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

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

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

直接模拟ac。静态链表

move函数怎么用呢　大牛能教一下么

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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