POJ 2253

POJ2253 (忘记初始化，然后怀孕了……浪费了2个小时啊尼玛)；

题目大意：在坐标系上给出n个点（2<=n<=200），每两个点直接可互相到达，所有从1到2的可能的路径中，最长的那条路径最短为多少

解：二分即可，二分枚举上界，再用dij求路径是否可能。

const
        maxn=200;
        bilibili=maxlongint>>1;
type
        point=record
          x, y: longint;
        end;

        graph=record
          next, dest: longint;
          cost: double;
        end;
var
        edge: array[1..maxn*maxn]of graph;
        w: array[1..maxn*maxn]of longint;
        a: array[1..maxn]of point;
        vect, heap, poss: array[1..maxn]of longint;
        dist: array[1..maxn]of double;
        s, n, tot, hptot: longint;
        key, ans: double;
procedure add(x, y: longint;z: double);
begin
  inc(tot);
  with edge[tot] do
    begin
      dest := y;
      cost := z;
      next := vect[x];
      vect[x] := tot;
    end;
end;

procedure qsort(b, e: longint);
var
        i, j, k: longint;
        x: double;
begin
  i := b;
  j := e;
  x := edge[w[(i+j)>>1]].cost;
  repeat
    while edge[w[i]].cost<x do inc(i);
    while edge[w[j]].cost>x do dec(j);
    if i<=j then
      begin
        k := w[i];
        w[i] := w[j];
        w[j] := k;
        inc(i);
        dec(j);
      end;
  until  i>j;
  if j>b then qsort(b, j);
  if i<e then qsort(i, e);
end;

procedure init;
var
        i, j, x, y: longint;
        aa, bb, tmp : double;
begin
  readln(n);
  if n=0 then
    begin
      close(input);
      close(output);
      halt;
    end;
  for i := 1 to n do
    with a[i] do
      readln(x, y);

  filldword(dist, sizeof(dist)>>2, bilibili);
  fillchar(poss, sizeof(poss), 0);
  fillchar(vect, sizeof(vect), 0);
  tot := 0;
  hptot := 0;
  ans := maxlongint;

  for i := 1 to n-1 do
    for j := i+1 to n do
      begin
        aa := (a[i].x-a[j].x)*(a[i].x-a[j].x);
        bb := (a[i].y-a[j].y)*(a[i].y-a[j].y);
        tmp := (aa+bb);
        tmp := sqrt(tmp);
        add(i, j, tmp);
        add(j, i, tmp);
      end;
  for i := 1 to tot do w[i] := i;
  qsort(1, tot);
end;

procedure print;
begin
  write('Scenario #');
  writeln(s);
  write('Frog Distance = ');
  writeln(ans:0:3);
  writeln;
end;

procedure up(x: longint);
var
        i, tmp: longint;
begin
  i := x;
  tmp := heap[x];
  while i>1 do
    begin
      if dist[tmp]<dist[heap[i >> 1]] then
        begin
          heap[i] := heap[i >> 1];
          poss[heap[i]] := i;
          i := i >> 1;
        end
      else break;
    end;
  heap[i] := tmp;
  poss[tmp] := i;
end;

procedure down(x: longint);
var
        i, j, tmp: longint;
begin
  i := x;
  tmp := heap[x];
  while i << 1<=hptot do
    begin
      j := i << 1;
      if (j+1<=hptot)and(dist[heap[j]]>dist[heap[j+1]]) then inc(j);
      if dist[tmp]>dist[heap[j]] then
        begin
          heap[i] := heap[j];
          poss[heap[i]] := i;
          i := j;
        end
      else break;
    end;
  heap[i] := tmp;
  poss[tmp] := i;
end;

procedure dijkstra(b, e: longint);
var
        i, u: longint;
begin
  hptot := 1;
  heap[1] := b;
  poss[b] := 1;
  dist[b] := 0;

  repeat
    u := heap[1];
    if u=e then
      begin
        exit;
      end;
    heap[1] := heap[hptot];
    poss[heap[1]] := 1;
    dec(hptot);
    down(1);
    i := vect[u];
    while i<>0 do
      with edge[i] do
        begin
          if cost<=key then
            begin
              if dist[u] + cost < dist[dest] then
                begin
                  dist[dest] := dist[u] + cost;
                  if poss[dest] = 0 then
                    begin
                      inc(hptot);
                      poss[dest] := hptot;
                      heap[hptot] := dest;
                      up(hptot);
                    end
                  else
                    up(poss[dest]);
                end;
            end;
          i := next;
        end;
  until hptot<1;
end;



procedure main;
var
        i, l, r, mid: longint;
begin
  s := 0;
  while true do
    begin
      inc(s);
      init;
      readln;
      l := 1;
      r := tot;
      while l<=r do
        begin
          mid :=  (l+r)>>1;
          key := edge[w[mid]].cost;
          for i := 1 to n do dist[i] := bilibili;
          fillchar(poss, sizeof(poss), 0);
          dijkstra(1, 2);
          if dist[2]<>bilibili then
            begin
              ans := key;
              r := mid-1;
            end
          else
            l := mid+1;
        end;

      print;
    end;

end;

begin
  //assign(input,'aaa.in'); reset(input);

  main;

  //close(input);
end.

var
        f: array[1..10, 1..10]of boolean;
        n, x, y, i: longint;
begin

  randomize;
  assign(output,'aaa.in'); rewrite(output);
  n := random(6)+1;
  writeln(n);
  fillchar(f, sizeof(f), 0);
  for i := 1 to n do
    begin
      repeat
        x := random(10)+1;
        y := random(10)+1;
      until not f[x, y];
      writeln(x, ' ', y);
    end;
  writeln;
  writeln(0);
  close(output);
end.