Алгоритмы на графах / bfs / bfs

{ graphs by boris }
{ breath-first search (order) }
{ Ї®ЁбЄ ў иЁаЁ­г }

const
  maxn = 250;                           { ¬ ЄбЁ¬ «м­®Ґ Є®«ЁзҐбвў® ўҐаиЁ­ }

const
  queue_size = maxn;                    { а §¬Ґа ®зҐаҐ¤Ё }

type
  item = integer;                       { вЁЇ н«Ґ¬Ґ­в  ®зҐаҐ¤Ё }

  queue = record                        { ®зҐаҐ¤м ­  Ў §Ґ ¬ ббЁў  }
    a: array [0..queue_size] of item;
    head, tail: integer;                { Ј®«®ў  Ё еў®бв }
  end;

{ Ё­ЁжЁ «Ё§ жЁп ®зҐаҐ¤Ё }
procedure init_queue(var q: queue);
begin
  q.head := 0;
  q.tail := 0;
end;

{ Ї®«®¦Ёвм ў ®зҐаҐ¤м }
procedure push_to_queue(var q: queue; x: item);
begin
  with q do
  begin
    a[tail] := x;
    tail := (tail + 1) mod queue_size;
  end;
end;

{ ў§пвм Ё§ ®зҐаҐ¤Ё }
function pop_from_queue(var q: queue): item;
begin
  with q do
  begin
    pop_from_queue := a[head];
    head := (head + 1) mod queue_size;
  end;
end;

{ Їа®ўҐаЁвм Їгбв  «Ё ®зҐаҐ¤м }
function is_queue_empty(const q: queue): boolean;
begin
  is_queue_empty := q.head = q.tail;
end;


var
  a: array [1..maxn, 1..maxn] of boolean;       { ¬ ваЁж  ᬥ¦­®бвЁ }
  q: queue;                                     { ®зҐаҐ¤м }
  visited: array [1..maxn] of boolean;          { Ї®бҐйҐ­  «Ё ўҐаиЁ­  }
  n: longint;

procedure init;
var
  i, x, y, nn: longint;
begin
  fillchar(a, sizeof(a), false);                { Ё­ЁжЁ «Ё§ жЁп ¤ ­­ле }
  fillchar(visited, sizeof(visited), false);

  assign(input, 'graph.in');                    { з⥭ЁҐ ¤ ­­ле }
  reset(input);

  read(n);
  read(nn);

  for i := 1 to nn do
  begin
    read(x, y);
    a[x, y] := true;
    a[y, x] := true;                    { Ґб«Ё ­Ґ®аЁҐ­вЁа®ў ­­л© Ја д }
  end;
end;

{ ЇҐз вм ¬ ваЁжл ᬥ¦­®бвЁ }
procedure print;
var
  i, j: integer;
begin
  writeln;
  writeln('number of vertex : ', n);
  writeln('adjacency matrix');
  for i := 1 to n do
  begin
    for j := 1 to n do
      write(ord(a[i, j]));
    writeln;
  end;
end;

{ Ї®ЁбЄ ў иЁаЁ­г }
{ v - ўҐаиЁ­  Ёбв®Є }
procedure bfs(v: longint);
var
  i: integer;
begin
  init_queue(q);
  push_to_queue(q, v);                   { Ї®«®¦Ё¬ ўҐаЁ­г v ў ®зҐаҐ¤м }
  visited[v] := true;                    { ўҐаиЁ­  v Ї®бҐйҐ­  }

  while not is_queue_empty(q) do         { Ї®Є  ®зҐаҐ¤м ­Ґ Їгбв  }
  begin
    v := pop_from_queue(q);              { ¤®бв Ґ¬ Ё§ ®зҐаҐ¤Ё ўҐаиЁ­г }
    for i := 1 to n do                   { ЇҐаҐЎЁа Ґ¬ ўбҐ ўҐаи­Ёл }
      if a[v, i] and not visited[i] then { Ґб«Ё ўҐаиЁ­  ᬥ¦­ п Ё }
      begin                              { ­ҐЇ®бҐйҐ­­ п }
        visited[i] := true;              { ўҐаиЁ­  i - Ї®бҐйҐ­  }
        push_to_queue(q, i);             { Ї®«®¦Ё¬ ўҐаиЁ­г i ў ®зҐаҐ¤м }
      end;
    write(v, ' ');                       { ®Ўа Ў®вЄ  ўҐаиЁ­л }
  end;
end;

var
  i: longint;

begin
  init;

  writeln('breath-first search (order)');
  for i := 1 to n do                     { ¤«п ўбҐе ­ҐЇ®бҐйҐ­­ле ўҐаиЁ­ }
    if not visited[i] then
      bfs(i);                            { ўл§®ўҐ¬ Ї®ЁбЄ ў иЁаЁ­г }

  print;
end.