一次AC,感谢Puppy

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

分治!!有学了点东西. ^-^

特贴上程序纪念一下

var

x,y:array[1..100000]of double;

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

procedure qsort(l,r: longint);

var

i,j: longint;

mid,t:double;

begin

i:=l; j:=r; mid:=x[(l+r) shr 1];

repeat

while x[i]j;

if l

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

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

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

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

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

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

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

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

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

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

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

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

太高效了吧····

要x y int64

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

枚局+剪枝就可以

编译通过...

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

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

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

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

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

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

　├ 错误行输出

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

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

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

　├ 错误行输出

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

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

Unaccepted 有效得分：80 有效耗时：306ms

郁闷啦

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

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

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

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

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

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

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

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

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

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

program v1012;

var

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

n,i,j,x,y:longint;

ans,min:extended;

function f(a,b,c,d:longint):extended;

var

x,y,x1,y1:extended;

begin

x:=a-b;y:=c-d;

x1:=sqr(x);y1:=sqr(y);

f:=sqrt(x1+y1);

end;

begin

readln(n);

for i:=1 to n do

readln(a,a);

min:=1.1e+4932;

for i:=1 to n-1 do

for j:=i+1 to n do

begin

ans:=f(a,a[j,1],a,a[j,2]);

if ans

我加了两优化。。。快到极点

1.枚举的过程中，如果x[j]-x[i]>=min就退出枚举j的那个循环继续下一个i的循环

2.按照X为第一关键字，Y为第二关键字排序，枚举I时，如果x[j]=x[i]，只需要找y[j]>y[i]的第一个数即可。x[j]x[i]的话只要找y[i]上方的那个点和y[i]下方的那个点即可。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

function dis(a,b:dot):double;

begin

dis:=sqr(a.x-b.x);

dis:=dis+sqr(a.y-b.y);

dis:=sqrt(dis);

end;

function meiju(x,y:longint):double;

var i,j:longint;

o:double;

begin

meiju:=1e12;

for i:=x to y-1 do

for j:=i+1 to y do

begin

o:=dis(a[i],a[j]);

if o=y+1);

dec(r);

o:=min2(l,ll,r);

if min>o then min:=o;

end;

分治法乱来过了

有点恶心。

第一次：看错题了，以为是最小生成树，没想到只是求最短的两点间距离。想复杂了

第二次-第n次:207浮点运算错误，0分。我以为是什么高深的错误，改了好多地方都不对，最后发现2^31次方刚刚超过longint(2^31-1)

第n+1次：改用int64，AC

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

欢迎大家踊跃copy

先排序，if a[j].x-a[i].x>min then break

小剪枝有大用处

program yz;

const inf = 'yz.in';

ouf = 'yz.out';

type point = record

x, y:double;

end;

var min, m: double;

i, n: longint;

p: array[1..100000] of point;

procedure qsx(l, r: longint);

var i, j: longint;

x, y: point;

begin

i := l;

j := r;

x := p[(i + j) div 2];

repeat

while (p[i].x < x.x) or ((p[i].x = x.x) and (p[i].y < x.y)) do inc(i);

while (p[j].x > x.x) or ((p[j].x = x.x) and (p[j].y > x.y)) do dec(j);

if i j;

if l < j then qsx(l, j);

if i < r then qsx(i, r);

end;

procedure qsy(l, r: longint);

var i, j: longint;

x, y: point;

begin

i := l;

j := r;

x := p[(i + j) div 2];

repeat

while (p[i].y < x.y) or ((p[i].y = x.y) and (p[i].x < x.x)) do inc(i);

while (p[j].y > x.y) or ((p[j].y = x.y) and (p[j].x > x.x)) do dec(j);

if i j;

if l < j then qsy(l, j);

if i < r then qsy(i, r);

end;

function jl(i, j:point): double;

begin

jl := sqr(i.x - j.x) + sqr(i.y - j.y);

end;

begin

assign(input, inf);

assign(output, ouf);

reset(input);

rewrite(output);

readln(n);

for i := 1 to n do

with p[i] do

read(x, y);

min := 1E100;

qsx(1, n);

for i := 1 to n-1 do begin

m := jl(p[i], p[i + 1]);

if m < min then

min := m;

end;

qsy(1, n);

for i := 1 to n-1 do begin

m := jl(p[i], p[i + 1]);

if m < min then

min := m;

end;

write(sqrt(min):0:3);

close(input);

close(output);

end.

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

纯搜索，快得喘不过气来了。。。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

先考虑一维的情况，二分中间点，在以求得的最小值为长度向中间点的两边拓展点，枚举这些点的距离，如果小于最优值则更新最优值。再考虑二维的情况，与一维相同，只不过是以中间点为中心，当前最优值为半径的圆里找点枚举

分治正解，要是想用枚举也能过...

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

总算过啦。。。。。

。

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

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

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

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

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

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

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

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

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

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

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

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

看来不能想太复杂。。 楼下0ms牛逼啊。

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

第10次 提交..

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

辛苦了 PUPPY

纪念一下,此乃本人通过之第200题.

编译通过...

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

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

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

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

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

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

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

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

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

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

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

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

今天RP低的真是可以,交了3次才过..

希望大家吸取我的教训..RP是很重要的!

编译通过...

├ 测试数据 01：运行时错误...| 错误号: 207 | 无效浮点运算

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

├ 测试数据 03：运行时错误...| 错误号: 207 | 无效浮点运算

├ 测试数据 04：运行时错误...| 错误号: 207 | 无效浮点运算

├ 测试数据 05：答案错误...

　├ 标准行输出1484.486

　├ 错误行输出 \(00407BEB
├ 测试数据 06：运行时错误...| 错误号: 216 | 存取非法
├ 测试数据 07：答案错误...
　├ 标准行输出17225.332
　├ 错误行输出 \)00407BEB

├ 测试数据 08：答案错误...

　├ 标准行输出40628.872

　├ 错误行输出 $00407BEB

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

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

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

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

后来我把所有关于结构体元素的变量从longint该成了real 结果是：

编译通过...

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

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

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

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

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

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

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

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

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

├ 测试数据 10：答案错误...

　├ 标准行输出11058.499

　├ 错误行输出 $00407FAB

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

什么意思啊？??? 我用的是快排+枚举+剪枝