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

{ graphs by boris }
{ minimal spanning tree (Kruskal's algorithm) }

const
  maxn = 100;                         {}
  maxm = 10000;                       {}
  inf  = maxint div 2;                {}

type
  edge = record
    x, y: integer;                    { ўҐаиЁ­л аҐЎа  }
    w: integer;                       { ўҐб аҐЎа  }
  end;

var
  a: array [1..maxm] of edge;         { бЇЁб®Є ॡҐа }
  s: array [1..maxn] of integer;      { а §¬Ґа Є®¬Ї®­Ґ­в бўп§­®бвЁ }
  r: array [1..maxn] of integer;      { бўп§Ё ўҐаиЁ­ ў Є®¬Ї®­Ґ­в е бўп§­®бвЁ }
  n, m: longint;                      { Є®«-ў® ўҐаиЁ­ Ё ॡҐа }
  mst_weight: longint;                { ўҐб MST}

{ Ё­ЁжЁ «Ё§ жЁп Ё з⥭ЁҐ ¤ ­­ле }
procedure init;
var
  i, j, x, y, nn, z: longint;
begin
  mst_weight := 0;
  assign(input, 'mst.in');
{  assign(input, 'randw.in');}
  reset(input);

  read(n);
  read(m);

  for i := 1 to m do
  begin
    read(x, y, z);
    a[i].x := x;
    a[i].y := y;
    a[i].w := z;
  end;
end;

{ ®Ў¬Ґ­ ¤ўге ॡҐа (¤«п б®авЁа®ўЄЁ) }
procedure swap(var e1, e2: edge);
var
  e: edge;
begin
  e := e1; e1 := e2; e2 := e;
end;

{ а ­¤®¬Ё§Ёа®ў ­­ п Ўлбва п б®авЁа®ўЄ  }
procedure qsort(l, r: integer);
var
  i, j, x: integer;
begin
  i := l;                               { i - «Ґў п Ја ­Ёж  }
  j := r;                               { j - Їа ў п Ја ­Ёж  }
  x := a[l+random(r-l+1)].w;            { x - б«гз ©­л© н«Ґ¬Ґ­в Ё§ Ё­вҐаў «  }

  repeat
    while x > a[i].w do inc(i);         { ЁйҐ¬ н«Ґ¬Ґ­в Ў®«миЁ© Ў амҐа  }
    while x < a[j].w do dec(j);         { ЁйҐ¬ н«Ґ¬Ґ­в ¬Ґ­миЁ© Ў амҐа  }

    if i <= j then                      { гЄ § вҐ«Ё ­Ґ ЇҐаҐбҐЄЄ«Ёбм }
    begin
      swap(a[i], a[j]);                 { ¬Ґ­пҐ¬ н«Ґ¬Ґ­вл }
      inc(i);                           { Їа®¤ўЁЈ Ґ¬ «Ґўл© гЄ § вҐ«м }
      dec(j);                           { Їа®¤ўЁЈ Ґ¬ Їа ўл© гЄ § вҐ«м }
    end;
  until i > j;                          { ¤® ЇҐаҐбҐзҐ­Ёп гЄ § вҐ«Ґ© }

  if l < j then qsort(l, j);            { б®авЁа㥬 «Ґўл© Ї®¤¬ ббЁў }
  if i < r then qsort(i, r);            { б®авЁа㥬 Їа ўл© Ї®¤¬ ббЁў }
end;

{ Ї®бв஥­ЁҐ mst ( «Ј®аЁв¬ ЉагбЄ « ) }
procedure kruskal;
var
  k, i, p, q: integer;
begin
  qsort(1, m);                        { б®авЁа㥬 бЇЁб®Є ॡҐа Ї® ­ҐгЎлў ­Ёо }

  for i := 1 to n do                  { жЁЄ« Ї® ўҐаиЁ­ ¬ }
  begin
    r[i] := i;                        { г ўҐаиЁ­  бў®п Є®¬Ї®­Ґ­в  бўп§­®бвЁ }
    s[i] := 1;                        { а §¬Ґа Є®¬Ї®­Ґ­вл бўп§­®бвЁ }
  end;

  k := 0;                             { ­®¬Ґа ЇҐаў®Ј® аҐЎа  + 1 }

  for i := 1 to n - 1 do              { жЁЄ« Ї® ॡࠬ mst }
  begin
    repeat                            { ЁйҐ¬ аҐЎа  Ё§ а §­ле }
      inc(k);                         { Є®¬Ї®­Ґ­в бўп§­®бвЁ  }
      p := a[k].x;
      q := a[k].y;
      while r[p] <> p do              { ЁйҐ¬ Є®аҐ­м ¤«п p }
        p := r[p];
      while r[q] <> q do              { ЁйҐ¬ Є®аҐ­м ¤«п q }
        q := r[q];
    until p <> q;

    writeln(a[k].x, ' ', a[k].y);     { ўлў®¤ аҐЎа  }
    inc(mst_weight, a[k].w);

    if s[p] < s[q] then               { ў§ўҐиҐ­­®Ґ ®ЎкҐ¤Ё­Ґ­ЁҐ }
    begin                             { Є®¬Ї®­Ґ­вл бўп§­®бвЁ   }
      r[p] := q;
      s[q] := s[q] + s[p];
    end
    else
    begin
      r[q] := p;
      s[p] := s[p] + s[q];
    end;
  end;
end;


begin
  init;
  writeln('minimal spanning tree (Kruskal''s algorithm)');
  kruskal;
  writeln('mst weight = ', mst_weight);
end.