[Algorithm][Greedy] Kruskal’s Minimum Spanning Tree Algorithm

概述

給出一個連通的無向圖，圖的生成樹是一個圖的子圖，而且是一棵鏈接了全部頂點的樹。

一個圖能夠有不少個生成樹，連通的有向圖和無向圖最小生成樹或最小權重生成樹是一棵權重小於其餘全部的生成樹的權重的生成樹。

生成樹的權重是生成樹中全部邊的權重的和。

算法

1. 對全部的邊按照非降序排序

2.從中選擇最小的邊，而且檢查它是否會和當前的樹構成一個環。若不構成環，則將這條邊加入最小生成樹，若構成環，則拋棄它。

3.重複步驟2直至有V-1條邊在生成樹中。 

注意

1.能夠用Union Find（並查集）來檢查是否存在環，（我認爲也能夠設定一個visited數組來記錄該頂點是否加入mst）

2. 當一個圖是連通的，若是咱們須要連通全部的節點，咱們至少須要V-1條邊。

 

例子

圖中含有9個節點，因此咱們須要9-1 = 8條邊來構成最小生成樹

對邊進行排序後：

After sorting:
Weight   Src    Dest
1         7      6
2         8      2
2         6      5
4         0      1
4         2      5
6         8      6
7         2      3
7         7      8
8         0      7
8         1      2
9         3      4
10        5      4
11        1      7
14        3      5

1. 取出7-6:無環，加入最小生成樹

2. 取出8-2:無環，加入最小生成樹

3. 取出6-5:無環，加入最小生成樹

4. 取出0-1:無環，加入最小生成樹

5. 取出2-5:無環，加入最小生成樹

6. 取出8-6:此時會造成環，不要該條邊

7. 取出2-3:無環，加入最小生成樹

8. P取出7-8:會生成環，不要該條邊

9. 取出2-5:無環，加入最小生成樹

10. 取出1-2:會生成環，不要這條變

11. 取出3-4:無環，加入最小生成樹

由於此時已經有8條變了，因此算法中止。

 

實現 

// C++ program for Kruskal's algorithm to find Minimum Spanning Tree // of a given connected, undirected and weighted graph
#include <stdio.h> #include <stdlib.h> #include <string.h>
 
// a structure to represent a weighted edge in graph
struct Edge { int src, dest, weight; }; // a structure to represent a connected, undirected // and weighted graph
struct Graph { // V-> Number of vertices, E-> Number of edges
    int V, E; // graph is represented as an array of edges. // Since the graph is undirected, the edge // from src to dest is also edge from dest // to src. Both are counted as 1 edge here.
    struct Edge* edge; }; // Creates a graph with V vertices and E edges
struct Graph* createGraph(int V, int E) { struct Graph* graph = new Graph; graph->V = V; graph->E = E; graph->edge = new Edge[E]; return graph; } // A structure to represent a subset for union-find
struct subset { int parent; int rank; }; // A utility function to find set of an element i // (uses path compression technique)
int find(struct subset subsets[], int i) { // find root and make root as parent of i // (path compression)
    if (subsets[i].parent != i) subsets[i].parent = find(subsets, subsets[i].parent); return subsets[i].parent; } // A function that does union of two sets of x and y // (uses union by rank)
void Union(struct subset subsets[], int x, int y) { int xroot = find(subsets, x); int yroot = find(subsets, y); // Attach smaller rank tree under root of high // rank tree (Union by Rank)
    if (subsets[xroot].rank < subsets[yroot].rank) subsets[xroot].parent = yroot; else if (subsets[xroot].rank > subsets[yroot].rank) subsets[yroot].parent = xroot; // If ranks are same, then make one as root and // increment its rank by one
    else { subsets[yroot].parent = xroot; subsets[xroot].rank++; } } // Compare two edges according to their weights. // Used in qsort() for sorting an array of edges
int myComp(const void* a, const void* b) { struct Edge* a1 = (struct Edge*)a; struct Edge* b1 = (struct Edge*)b; return a1->weight > b1->weight; } // The main function to construct MST using Kruskal's algorithm
void KruskalMST(struct Graph* graph) { int V = graph->V; struct Edge result[V];  // Tnis will store the resultant MST
    int e = 0;  // An index variable, used for result[]
    int i = 0;  // An index variable, used for sorted edges // Step 1: Sort all the edges in non-decreasing // order of their weight. If we are not allowed to // change the given graph, we can create a copy of // array of edges
    qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp); // Allocate memory for creating V ssubsets
    struct subset *subsets = (struct subset*) malloc( V * sizeof(struct subset) ); // Create V subsets with single elements
    for (int v = 0; v < V; ++v) { subsets[v].parent = v; subsets[v].rank = 0; } // Number of edges to be taken is equal to V-1
    while (e < V - 1) { // Step 2: Pick the smallest edge. And increment // the index for next iteration
        struct Edge next_edge = graph->edge[i++]; int x = find(subsets, next_edge.src); int y = find(subsets, next_edge.dest); // If including this edge does't cause cycle, // include it in result and increment the index // of result for next edge
        if (x != y) { result[e++] = next_edge; Union(subsets, x, y); } // Else discard the next_edge
 } // print the contents of result[] to display the // built MST
    printf("Following are the edges in the constructed MST\n"); for (i = 0; i < e; ++i) printf("%d -- %d == %d\n", result[i].src, result[i].dest, result[i].weight); return; } // Driver program to test above functions
int main() { /* Let us create following weighted graph 10 0--------1 | \ | 6| 5\ |15 | \ | 2--------3 4 */
    int V = 4;  // Number of vertices in graph
    int E = 5;  // Number of edges in graph
    struct Graph* graph = createGraph(V, E); // add edge 0-1
    graph->edge[0].src = 0; graph->edge[0].dest = 1; graph->edge[0].weight = 10; // add edge 0-2
    graph->edge[1].src = 0; graph->edge[1].dest = 2; graph->edge[1].weight = 6; // add edge 0-3
    graph->edge[2].src = 0; graph->edge[2].dest = 3; graph->edge[2].weight = 5; // add edge 1-3
    graph->edge[3].src = 1; graph->edge[3].dest = 3; graph->edge[3].weight = 15; // add edge 2-3
    graph->edge[4].src = 2; graph->edge[4].dest = 3; graph->edge[4].weight = 4; KruskalMST(graph); return 0; }

 

以上均來自於：https://www.geeksforgeeks.org/?p=26604