Boruvka's algorithm | Greedy Algo-9

// Boruvka's algorithm to find Minimum Spanning
// Tree of a given connected, undirected and weighted graph
using System;
using System.Collections.Generic;

// Class to represent a graph
class Graph {
    private int V; // No. of vertices
    private List<List<int> >
        graph; // default dictionary to store graph

    // A utility function to find set of an element i
    // (uses path compression technique)
    private int Find(List<int> parent, int i)
    {
        if (parent[i] == i) {
            return i;
        }
        return Find(parent, parent[i]);
    }

    // A function that does union of two sets of x and y
    // (uses union by rank)
    private void UnionSet(List<int> parent, List<int> rank,
                          int x, int y)
    {
        int xroot = Find(parent, x);
        int yroot = Find(parent, y);

        // Attach smaller rank tree under root of high rank
        // tree (Union by Rank)
        if (rank[xroot] < rank[yroot]) {
            parent[xroot] = yroot;
        }
        else if (rank[xroot] > rank[yroot]) {
            parent[yroot] = xroot;
        }

        // If ranks are same, then make one as root and
        // increment its rank by one
        else {
            parent[yroot] = xroot;
            rank[xroot]++;
        }
    }

    public Graph(int vertices)
    {
        V = vertices;
        graph = new List<List<int> >();
    }

    // function to add an edge to graph
    public void AddEdge(int u, int v, int w)
    {
        graph.Add(new List<int>{ u, v, w });
    }

    // The main function to construct MST using Kruskal's
    // algorithm
    public void boruvkaMST()
    {
        List<int> parent = new List<int>();

        // An array to store index of the cheapest edge of
        // subset. It store [u,v,w] for each component
        List<int> rank = new List<int>();
        List<List<int> > cheapest = new List<List<int> >();

        // Initially there are V different trees.
        // Finally there will be one tree that will be MST
        int numTrees = V;
        int MSTweight = 0;

        // Create V subsets with single elements
        for (int node = 0; node < V; node++) {
            parent.Add(node);
            rank.Add(0);
            cheapest.Add(new List<int>{ -1, -1, -1 });
        }

        // Keep combining components (or sets) until all
        // components are not combined into single MST
        while (numTrees > 1) {

            // Traverse through all edges and update
            // cheapest of every component
            for (int i = 0; i < graph.Count; i++) {

                // Find components (or sets) of two corners
                // of current edge
                int u = graph[i][0], v = graph[i][1],
                    w = graph[i][2];
                int set1 = Find(parent, u),
                    set2 = Find(parent, v);

                // If two corners of current edge belong to
                // same set, ignore current edge. Else check
                // if current edge is closer to previous
                // cheapest edges of set1 and set2
                if (set1 != set2) {
                    if (cheapest[set1][2] == -1
                        || cheapest[set1][2] > w) {
                        cheapest[set1]
                            = new List<int>{ u, v, w };
                    }
                    if (cheapest[set2][2] == -1
                        || cheapest[set2][2] > w) {
                        cheapest[set2]
                            = new List<int>{ u, v, w };
                    }
                }
            }

            // Consider the above picked cheapest edges and
            // add them to MST
            for (int node = 0; node < V; node++) {

                // Check if cheapest for current set exists
                if (cheapest[node][2] != -1) {
                    int u = cheapest[node][0],
                        v = cheapest[node][1],
                        w = cheapest[node][2];
                    int set1 = Find(parent, u),
                        set2 = Find(parent, v);
                    if (set1 != set2) {
                        MSTweight += w;
                        UnionSet(parent, rank, set1, set2);
                        Console.WriteLine(
                            "Edge {0}-{1} with weight {2} included in MST",
                            u, v, w);
                        numTrees--;
                    }
                }
            }
            for (int node = 0; node < V; node++) {
                // reset cheapest array
                cheapest[node][2] = -1;
            }
        }
        Console.WriteLine("Weight of MST is {0}",
                          MSTweight);
    }
}

public class GFG {
    static void Main(string[] args)
    {
        Graph g = new Graph(4);
        g.AddEdge(0, 1, 10);
        g.AddEdge(0, 2, 6);
        g.AddEdge(0, 3, 5);
        g.AddEdge(1, 3, 15);
        g.AddEdge(2, 3, 4);
        g.boruvkaMST();
    }
}
// This code is contributed by prasad264