Prim’s Algorithm for Minimum Spanning Tree (MST)

// A C# program for Prim's Minimum Spanning Tree (MST)
// algorithm. The program is for adjacency matrix
// representation of the graph

using System;
using System.Collections.Generic;

class MST
{
    // A utility function to find the vertex with minimum
    // key value, from the set of vertices not yet included
    // in MST
    int MinKey(int[] key, bool[] mstSet)
    {
        // Initialize min value
        int min = int.MaxValue, minIndex = -1;

        for (int v = 0; v < mstSet.Length; v++)
            if (!mstSet[v] && key[v] < min)
            {
                min = key[v];
                minIndex = v;
            }

        return minIndex;
    }

    // A utility function to print the constructed MST
    // stored in parent[]
    void PrintMST(int[] parent, int[,] graph)
    {
        Console.WriteLine("Edge \tWeight");
        for (int i = 1; i < graph.GetLength(0); i++)
            Console.WriteLine(parent[i] + " - " + i + "\t" + graph[parent[i], i]);
    }

    // Function to construct and print MST for a graph
    // represented using adjacency matrix representation
    public void PrimMST(int[,] graph)
    {
        int V = graph.GetLength(0);

        // Array to store constructed MST
        int[] parent = new int[V];

        // Key values used to pick minimum weight edge in
        // cut
        int[] key = new int[V];

        // To represent set of vertices included in MST
        bool[] mstSet = new bool[V];

        // Initialize all keys as INFINITE
        for (int i = 0; i < V; i++)
        {
            key[i] = int.MaxValue;
            mstSet[i] = false;
        }

        // Always include first 1st vertex in MST.
        // Make key 0 so that this vertex is
        // picked as first vertex
        key[0] = 0;

        // First node is always root of MST
        parent[0] = -1;

        // The MST will have V vertices
        for (int count = 0; count < V - 1; count++)
        {
            // Pick the minimum key vertex from the set of
            // vertices not yet included in MST
            int u = MinKey(key, mstSet);

            // Add the picked vertex to the MST Set
            mstSet[u] = true;

            // Update key value and parent index of the
            // adjacent vertices of the picked vertex.
            // Consider only those vertices which are not
            // yet included in MST
            for (int v = 0; v < V; v++)
                // graph[u][v] is non zero only for adjacent
                // vertices of m mstSet[v] is false for
                // vertices not yet included in MST Update
                // the key only if graph[u][v] is smaller
                // than key[v]
                if (graph[u, v] != 0 && !mstSet[v] && graph[u, v] < key[v])
                {
                    parent[v] = u;
                    key[v] = graph[u, v];
                }
        }

        // Print the constructed MST
        PrintMST(parent, graph);
    }

    public static void Main(string[] args)
    {
        MST t = new MST();
        int[,] graph = new int[,] { { 0, 2, 0, 6, 0 },
                                      { 2, 0, 3, 8, 5 },
                                      { 0, 3, 0, 0, 7 },
                                      { 6, 8, 0, 0, 9 },
                                      { 0, 5, 7, 9, 0 } };

        // Print the solution
        t.PrimMST(graph);
    }
}

using System;
using System.Collections.Generic;

public class MinimumSpanningTree
{
    // Function to find sum of weights of edges of the Minimum Spanning Tree.
    public static int SpanningTree(int V, int E, int[,] edges)
    {
        // Create an adjacency list representation of the graph
        List<List<int[]>> adj = new List<List<int[]>>();
        for (int i = 0; i < V; i++)
        {
            adj.Add(new List<int[]>());
        }

        // Fill the adjacency list with edges and their weights
        for (int i = 0; i < E; i++)
        {
            int u = edges[i, 0];
            int v = edges[i, 1];
            int wt = edges[i, 2];
            adj[u].Add(new int[] { v, wt });
            adj[v].Add(new int[] { u, wt });
        }

        // Create a priority queue to store edges with their weights
        PriorityQueue<(int, int)> pq = new PriorityQueue<(int, int)>();

        // Create a visited array to keep track of visited vertices
        bool[] visited = new bool[V];

        // Variable to store the result (sum of edge weights)
        int res = 0;

        // Start with vertex 0
        pq.Enqueue((0, 0));

        // Perform Prim's algorithm to find the Minimum Spanning Tree
        while (pq.Count > 0)
        {
            var p = pq.Dequeue();
            int wt = p.Item1;  // Weight of the edge
            int u = p.Item2;  // Vertex connected to the edge

            if (visited[u])
            {
                continue;  // Skip if the vertex is already visited
            }

            res += wt;  // Add the edge weight to the result
            visited[u] = true;  // Mark the vertex as visited

            // Explore the adjacent vertices
            foreach (var v in adj[u])
            {
                // v[0] represents the vertex and v[1] represents the edge weight
                if (!visited[v[0]])
                {
                    pq.Enqueue((v[1], v[0]));  // Add the adjacent edge to the priority queue
                }
            }
        }

        return res;  // Return the sum of edge weights of the Minimum Spanning Tree
    }

    public static void Main()
    {
        int[,] graph = { { 0, 1, 5 }, { 1, 2, 3 }, { 0, 2, 1 } };

        // Function call
        Console.WriteLine(SpanningTree(3, 3, graph));
    }
}

// PriorityQueue implementation for C#
public class PriorityQueue<T> where T : IComparable<T>
{
    private List<T> heap = new List<T>();

    public int Count => heap.Count;

    public void Enqueue(T item)
    {
        heap.Add(item);
        int i = heap.Count - 1;
        while (i > 0)
        {
            int parent = (i - 1) / 2;
            if (heap[parent].CompareTo(heap[i]) <= 0)
                break;

            Swap(parent, i);
            i = parent;
        }
    }

    public T Dequeue()
    {
        int lastIndex = heap.Count - 1;
        T frontItem = heap[0];
        heap[0] = heap[lastIndex];
        heap.RemoveAt(lastIndex);

        --lastIndex;
        int parent = 0;
        while (true)
        {
            int leftChild = parent * 2 + 1;
            if (leftChild > lastIndex)
                break;

            int rightChild = leftChild + 1;
            if (rightChild <= lastIndex && heap[leftChild].CompareTo(heap[rightChild]) > 0)
                leftChild = rightChild;

            if (heap[parent].CompareTo(heap[leftChild]) <= 0)
                break;

            Swap(parent, leftChild);
            parent = leftChild;
        }

        return frontItem;
    }

    private void Swap(int i, int j)
    {
        T temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}