Krusekal算法

program Project1;
type node=record
                front,rear:longint;
                cost:longint;
                end;
var a:array[1..1000000]of node;
    b:array[1..1000]of longint;
    i,min,n,m,x,y,t:longint;
function findan(n:longint):longint;
begin
     while n<>b[n] do n:=b[n];
     findan:=n;
end;
procedure swap(var a,b:node);
var t:node;
begin
     t:=a;a:=b;b:=t;
end;
procedure Sort(l, r: longint);
var
   i, j, x: longint;
   y: node;
   begin
   i := l; j := r; x := a[(l+r) DIV 2].cost;
   repeat
         while a[i].cost < x do i := i + 1;
         while x < a[j].cost do j := j - 1;
         if i <= j then
            begin
                 y := a[i]; a[i] := a[j]; a[j] := y;
                 i := i + 1; j := j - 1;
            end;
   until i > j;
   if l < j then Sort(l, j);
   if i < r then Sort(i, r);
end;
procedure krusekal;
var i,j,ingraph:longint;
    t:node;
begin
     sort(1,m);
     min:=0;
     ingraph:=0;
     i:=0;
     while ingraph<n-1 do
     begin
          inc(i);
          if findan(a[i].front)<>findan(a[i].rear) then
          begin
               min:=min+a[i].cost;
               b[findan(a[i].front)]:=findan(a[i].rear);
               inc(ingraph);
          end;
     end;
end;
begin
     readln(n,m);
     for i:=1 to m do
     begin
          readln(x,y,t);
          a[i].front:=x;
          a[i].rear:=y;
          a[i].cost:=t;
     end;
     for i:=1 to n do b[i]:=i;
     krusekal;
     writeln(min);
end. 

Krusekal.in
7 9
1 2 28
1 6 10
2 3 16
2 7 14
3 4 12
4 5 22
4 7 18
5 6 25
5 7 24

Krusekal.out
1,6
3,4
2,7
2,3
4,5
5,6
99

Kruskal算法是一种用来寻找最小生成树的算法，由Joseph Kruskal在1956年发表。用来解决同样问题的还有Prim算法。

步骤

1. 新建图G，G中拥有原图中相同的节点，但没有边
2. 将原图中所有的边按权值从小到大排序
3. 从权值最小的边开始，如果这条边连接的两个节点于图G中不在同一个连通分量中，则添加这条边到图G中
4. 重复3，直至图G中所有的节点都在同一个连通分量中

证明

1. 这样的步骤保证了选取的每条边都是桥，因此图G构成一个树。
2. 为什么这一定是最小生成树呢？关键还是步骤3中对边的选取。算法中总共选取了n-1条边，每条边在选取的当时，都是连接两个不同的连通分量的权值最小的边
3. 要证明这条边一定属于最小生成树，可以用反证法：如果这条边不在最小生成树中，它连接的两个连通分量最终还是要连起来的，通过其它的连法，那么另一种连法与这条边一定构成了环，而环中一定有一条权值大于这条边的边，用这条边将其替换掉，图仍旧保持连通，但总权值减小了。也就是说，如果不选取这条边，最后构成的生成树的总权值一定不会是最小的。

注意:不是将头尾合并(上面有误),而是头尾的祖先相连！

b[findan(a[i].front)]:=findan(a[i].rear);