Scribd
Upload
2 views

Ayesha Assignment Algo

The document outlines Kruskal's Algorithm for finding the minimum spanning tree (MST) of a graph, detailing the steps including sorting edges, using a Union-Find data structure to avoid cycles, and calculating the MST's total weight. It provides a C++ implementation of the algorithm, demonstrating how to add edges and compute the MST with example output. The time complexity is O(E log E) and the space complexity is O(E + V).

Uploaded by

bushrajalil88
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
2 views

Ayesha Assignment Algo

The document outlines Kruskal's Algorithm for finding the minimum spanning tree (MST) of a graph, detailing the steps including sorting edges, using a Union-Find data structure to avoid cycles, and calculating the MST's total weight. It provides a C++ implementation of the algorithm, demonstrating how to add edges and compute the MST with example output. The time complexity is O(E log E) and the space complexity is O(E + V).

Uploaded by

bushrajalil88
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 7

ASSIGNMENT ALGO

Ayesha 22BSCS016

BSCS-5

Jalil

Solution
Kruskal's Algorithm
The inputs taken by the kruskal’s algorithm are the graph G {V, E}, where V is the set of vertices and E is the set of
edges, and the source vertex S and the minimum spanning tree of graph G is obtained as an output.

Algorithm

 Sort all the edges in the graph in an ascending order and store it in an array edge[].

 Construct the forest of the graph on a plane with all the vertices in it.

 Select the least cost edge from the edge[] array and add it into the forest of the graph. Mark the vertices
visited by adding them into the visited[] array.

 Repeat the steps 2 and 3 until all the vertices are visited without having any cycles forming in the graph

 When all the vertices are visited, the minimum spanning tree is formed.

 Calculate the minimum cost of the output spanning tree formed.

Steps of the Algorithm:*


1. *Sort edges* by weight in ascending order.

2. Use the *Union-Find (Disjoint Set Union)* data structure to check for cycles:

- Each vertex starts as its own parent (forming separate sets).

- For each edge, check if its vertices belong to the same set:

- If not, include it in the MST (merge the sets).

- Otherwise, skip the edge (as it would form a cycle).

3. Repeat until the MST contains ( n - 1 ) edges, where ( n ) is the number of vertices.

Time Complexity :The time complexity of Kruskal's algorithm is O(E log E) or O(E log V), where E is the
number of edges and V is the number of vertices.
Space Complexity : The space complexity of Kruskal's algorithm is O(E + V), where E is the number of
edges and V is the number of vertices.

Code:
#include <iostream>

using namespace std;

// DSU data structure

// path compression + rank by union

class DSU {

int* parent;

int* rank;

public:

DSU(int n)

parent = new int[n];

rank = new int[n];

for (int i = 0; i < n; i++) {

parent[i] = -1;

rank[i] = 1;

// Find function

int find(int i)

if (parent[i] == -1)

return i;
return parent[i] = find(parent[i]);

// Union function

void unite(int x, int y)

int s1 = find(x);

int s2 = find(y);

if (s1 != s2) {

if (rank[s1] < rank[s2]) {

parent[s1] = s2;

else if (rank[s1] > rank[s2]) {

parent[s2] = s1;

else {

parent[s2] = s1;

rank[s1] += 1;

};

class Graph {

vector<vector<int> > edgelist;

int V;

public:

Graph(int V) { this->V = V; }
// Function to add edge in a graph

void addEdge(int x, int y, int w)

edgelist.push_back({ w, x, y });

void kruskals_mst()

// Sort all edges

sort(edgelist.begin(), edgelist.end());

// Initialize the DSU

DSU s(V);

int ans = 0;

int count = 0; // To keep track of the number of edges in MST

cout << "Following are the edges in the "

"constructed MST"

<< endl;

for (auto edge : edgelist) {

int w = edge[0];

int x = edge[1];

int y = edge[2];

// Take this edge in MST if it does

// not forms a cycle

if (s.find(x) != s.find(y)) {

s.unite(x, y);

ans += w;

cout << x << " -- " << y << " == " << w

<< endl;

count++; // Increase the count of edges added to MST


}

if (count == V - 1) {

break;

cout << "Minimum Cost Spanning Tree: " << ans;

};

// Driver code

int main()

Graph g(4);

g.addEdge(0, 1, 10);

g.addEdge(1, 3, 15);

g.addEdge(2, 3, 4);

g.addEdge(2, 0, 6);

g.addEdge(0, 3, 5);

// Function call

g.kruskals_mst();

return 0;

}
Explanation of Output:

- The algorithm picks the edges with the smallest weights first, ensuring no cycles are formed- The final
MST consists of:

- ( ('E', 'D', 1) )

- ( ('C', 'E', 2) )

- ( ('A', 'C', 3) )

- ( ('A', 'B', 4) )

- The total weight of the MST is \( 1 + 2 + 3 + 4 = 10 \)

This solution meets all requirements: computing the MST and displaying the edges with their total weight.

You might also like