SPFA+链表

type point=^node;
     node=record
            data，zhi:longint;
            next:point;
          end;
var
  x,y:longint;
  n,m,c,i,j,u,z,max,tail,head:longint;
  p,v:point;
  a:array[1..300000]of point;
  pp:array[1..300000]of boolean;
  dis,team:array[1..300000]of longint;
begin
  assign(input,'candy.in');
  assign(output,'candy.out');

  reset(input);rewrite(output);

  readln(n,m,c);

  {n表示点，m表示边，c表示起点}

  for i:=1 to m do
    begin
      read(x,y);
      new(p);
      p^.data:=y;
      p^.zhi:=1;
      p^.next:=a[x];
      a[x]:=p;
      new(p);
      p^.data:=x;
      p^.zhi:=1;
      p^.next:=a[y];

      a[y]:=p;

      {因为是无向图，所以要做两次}

    end;
  for i:=1 to n do dis[i]:=maxlongint div 2;

  dis[c]:=0;team[1]:=c;head:=0;tail:=1;pp[c]:=true;

  {将起点最短值定为0，将头指针，尾指针，各个点使用情况定初值}

  repeat
    inc(head);
    u:=team[head];
    pp[u]:=false;
    v:=a[u];
    while v<>nil do
      begin
        if dis[v^.data]>dis[u]+1 then
          begin
            dis[v^.data]:=dis[u]+1;
            if pp[v^.data]=false then
              begin
                inc(tail);
                team[tail]:=v^.data;
                pp[v^.data]:=true;
              end;
          end;

         v:=v^.next;

         {指针邻接表}

      end;

  until head>=tail;

  {SPFA}

  max:=0;
  for i:=1 to n do

    writeln(dis[i]);

  {输出从起点到各个点的最短值}

  close(input);close(output);

end.

有了SPFA+邻接表，遇到最短路就不怕了，当然，dijkstra+堆优化也是一好方法。

明天就看看单调队列。