How can I implement Dijkstra's algorithm in C#?

How can I implement Dijkstra's algorithm in C#?

To implement Dijkstra's algorithm in C#, you can use a priority queue to efficiently get the next node with the smallest distance.

Can you provide a sample code for that?

Sure! Here's a simple implementation:

using System;
using System.Collections.Generic;

class Graph {
    private Dictionary<int, List<(int, int)>> adjList = new Dictionary<int, List<(int, int)>>();

    public void AddEdge(int source, int destination, int weight) {
        if (!adjList.ContainsKey(source)) adjList[source] = new List<(int, int)>();
        adjList[source].Add((destination, weight));
    }

    public void Dijkstra(int start) {
        var distances = new Dictionary<int, int>();
        var priorityQueue = new SortedSet<(int distance, int vertex)>(Comparer<(int, int)>.Create((a, b) => a.distance == b.distance ? a.vertex.CompareTo(b.vertex) : a.distance.CompareTo(b.distance)));

        foreach (var vertex in adjList.Keys) {
            distances[vertex] = int.MaxValue;
        }
        distances[start] = 0;
        priorityQueue.Add((0, start));

        while (priorityQueue.Count > 0) {
            var (currentDistance, currentVertex) = priorityQueue.Min;
            priorityQueue.Remove(priorityQueue.Min);

            foreach (var (neighbor, weight) in adjList[currentVertex]) {
                var distance = currentDistance + weight;
                if (distance < distances[neighbor]) {
                    distances[neighbor] = distance;
                    priorityQueue.Add((distance, neighbor));
                }
            }
        }

        foreach (var vertex in distances.Keys) {
            Console.WriteLine($"Distance from {start} to {vertex} is {distances[vertex]}");
        }
    }
}

What are the time and space complexities of this algorithm?

The time complexity of Dijkstra's algorithm using a priority queue is O((V + E) log V), where V is the number of vertices and E is the number of edges. The space complexity is O(V) for storing the distances.