172 lines
3.3 KiB
C++
172 lines
3.3 KiB
C++
//Graph Kruskal algorithm
|
|
#include <bits/stdc++.h>
|
|
using namespace std;
|
|
|
|
class Edge {
|
|
public:
|
|
int src, dest, weight;
|
|
};
|
|
|
|
class Graph {
|
|
public:
|
|
|
|
int V, E;
|
|
Edge* edge;
|
|
};
|
|
|
|
// Creates a graph with V vertices and E edges
|
|
Graph* createGraph(int V, int E)
|
|
{
|
|
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
|
|
class subset {
|
|
public:
|
|
int parent;
|
|
int rank;
|
|
};
|
|
|
|
|
|
int find(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(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)
|
|
{
|
|
Edge* a1 = (Edge*)a;
|
|
Edge* b1 = (Edge*)b;
|
|
return a1->weight > b1->weight;
|
|
}
|
|
|
|
// The main function to construct MST using Kruskal's
|
|
// algorithm
|
|
void KruskalMST(Graph* graph)
|
|
{
|
|
int V = graph->V;
|
|
Edge result[V]; // Tnis will store the resultant MST
|
|
int e = 0; // An index variable, used for result[]
|
|
int i = 0;
|
|
|
|
|
|
qsort(graph->edge, graph->E, sizeof(graph->edge[0]),
|
|
myComp);
|
|
|
|
// Allocate memory for creating V ssubsets
|
|
subset* subsets = new subset[(V * sizeof(subset))];
|
|
|
|
// Create V subsets with single elements
|
|
for (int v = 0; v < V; ++v)
|
|
{
|
|
subsets[v].parent = v;
|
|
subsets[v].rank = 0;
|
|
}
|
|
|
|
while (e < V - 1 && i < graph->E)
|
|
{
|
|
|
|
Edge next_edge = graph->edge[i++];
|
|
|
|
int x = find(subsets, next_edge.src);
|
|
int y = find(subsets, next_edge.dest);
|
|
|
|
|
|
if (x != y) {
|
|
result[e++] = next_edge;
|
|
Union(subsets, x, y);
|
|
}
|
|
// Else discard the next_edge
|
|
}
|
|
|
|
|
|
cout << "Following are the edges in the "
|
|
"MST\n";
|
|
int minimumCost = 0;
|
|
for (i = 0; i < e; ++i)
|
|
{
|
|
cout << result[i].src << " -- " << result[i].dest
|
|
<< " == " << result[i].weight << endl;
|
|
minimumCost = minimumCost + result[i].weight;
|
|
}
|
|
cout << "Minimum Cost Spanning Tree: " << minimumCost
|
|
<< endl;
|
|
}
|
|
|
|
// Helper function which takes in src, dest, weight, index, address of graph as an argument
|
|
// to update the value of graph for respective index
|
|
void updateGraph(int s, int d, int w, int idx, Graph** graph){
|
|
graph->edge[idx].src = s;
|
|
graph->edge[idx].dest = d;
|
|
graph->edge[idx].weight = w;
|
|
}
|
|
|
|
// Driver code
|
|
int main()
|
|
{
|
|
|
|
|
|
int V = 4; // Number of vertices in graph
|
|
int E = 5; // Number of edges in graph
|
|
Graph* graph = createGraph(V, E);
|
|
|
|
// add edge 0-1
|
|
updateGraph(0, 1, 10, 0, &graph);
|
|
|
|
// add edge 0-2
|
|
updateGraph(0, 2, 6, 1, &graph);
|
|
|
|
// add edge 0-3
|
|
updateGraph(0, 3, 5, 2, &graph);
|
|
|
|
// add edge 1-3
|
|
updateGraph(1, 3, 15, 3, &graph);
|
|
|
|
// add edge 2-3
|
|
updateGraph(2, 3, 4, 4, &graph);
|
|
|
|
|
|
|
|
KruskalMST(graph);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|