编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

没看到最后给的 time的范围~

结果 想了一下午 最后才发现是INTEGER惹的祸

靠，居然不用排序！！气死我啦

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

经典题，经典方法，最长XX序列

彻底傻了！

第一次：n和m看反了，10分

第二次：数组开了1000，少了一位，30分

第三次：终于AC了，不过不够华丽，就不在这里贴了，以免受bs

细节决定成败啊！

ps：赞一下herself大牛的dp

如果把

"可以从第a个点及时赶到第b个点打鼹鼠"

理解为a

最长不降子序列原来可以这样来

———————获益啊—

真危险！用t=x[i]-x[j]>0?t:-t 只能过3组，改成ABS刚刚过。。。

不知还有什么可以优化的？

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

#include

int main()

{

int i,j,n,m,time[10001],x[10001],y[10001],num[10001]={0};

int max=0,yt,xt;

scanf("%d %d",&n,&m);

for(i=1;i=1;i--)

{

for(j=i+1;j=abs(y[i]-y[j])+abs(x[i]-x[j])&&num[i]

不可思议！！！

用 to 只能过3组的程序，

换成downto竟然就A了！！

有差这么多吗？？？？！！！！！！！

长见识了

downto 竟然比 to 快!

唉....我太无知了...

55555555

可计算出来第i只老鼠到地图四个角所需的时间最大值，当时间差大于就这个最大值就意味着能走到地图任意位置。

可以记录一下max[n]=max{f[i]}(ia then a:=b;

end;

begin

readln(n,m);

for i:=1 to m do

readln(t[i],x[i],y[i]);

max[1]:=1;

f[1]:=1;

for i:=2 to m do

begin

bu:=x[i]+y[i];

update(bu,n-x[i]+n-y[i]);

update(bu,n-x[i]+y[i]);

update(bu,x[i]+n-y[i]);

f[i]:=1;

k:=i-1;

while (k>=1) and (t[i]-t[k]=abs(x[i]-x[k])+abs(y[i]-y[k]) then

update(f[i],f[k]+1);

dec(k);

end;

if k0 then update(f[i],max[k]+1);

if f[i]>max then max[i]:=f[i] else max[i]:=max;

end;

k:=-1;

for i:=1 to m do

update(k,f[i]);

writeln(k);

end.

千万不要判断是不是>n

注意同一时刻同一地点可能出现两只！！

题目题目说明有误！！

阴了好多人

O(n^2)可以过

但是似乎得看语言...

pascal,c可以

c++就不行...我怎么优化都超时，除非NlogN...

其实就是LIS...

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

最长不降子序列的翻版!!!!其实数据应该改大点让N^2的全过不去....

2分+连表+DP.....核心代码....

for i:=2 to n do

begin

a[0].x:=a[i].x;a[0].y:=a[i].y;a[0].time:=0;

k:=fmax(0,max)+1;

if k>max then max:=k;

if c[k].next=0 then begin c[k].next:=k;c[k].w:=i;end

else begin

inc(m);

while c[k].nextk do

k:=c[k].next;

c[k].next:=m;c[m].next:=m;c[m].w:=i;

end;

end;

这题复杂度达5000W，接近边缘，常数优化很重要。

如用c++的inline写abs，j从大到小写循环，scanf读写等等

f[i]定义为一定打第i只鼹鼠，前i只能打的最多的鼹鼠数，故f[i]至少=1

f[i] = max{f[j]}+1 (1

"注意同一时刻可能出现多只鼹鼠，但同一时刻同一地点只可能出现一只鼹鼠。 "

这句描述有误

同楼上的..

我也是被这数据WS了..

10分一下掉了10名..

"注意同一时刻可能出现多只鼹鼠，但同一时刻同一地点只可能出现一只鼹鼠。 "

这是题目中的原话。

我下了数据以后发现，input.001中有这样一种数据：

10 10

3 1 5

4 3 4

4 8 9

4 3 4

4 5 3

4 10 8

6 4 5

8 2 3

8 8 4

8 6 3

这直接导致了数据的错误。

我想，这阴了不少人。包括我