// Dijkstra's shortest paths algorithm, implemented // with priority queue. Running time: O(M * log M) // Learn more at: https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Using_a_priority_queue public static void DijkstraAlgorithm( Dictionary<Node, List<Edge>> graph, Node sourceNode) { var queue = new PriorityQueue<Node>(); foreach (var node in graph) { node.Key.Distance = double.PositiveInfinity; } sourceNode.Distance = 0.0d; queue.Enqueue(sourceNode); while (queue.Count != 0) { var currentNode = queue.Dequeue(); if (double.IsPositiveInfinity(currentNode.Distance)) { // All nodes processed --> algorithm finished break; } foreach (var childEdge in graph[currentNode]) { var newDistance = currentNode.Distance + childEdge.Distance; if (newDistance < childEdge.Node.Distance) { childEdge.Node.Distance = newDistance; childEdge.Node.PreviousNode = currentNode; queue.Enqueue(childEdge.Node); } } } }
public static void DijkstraAlgorithm(Dictionary<Node, List<Connection>> graph, Node source) { var queue = new PriorityQueue<Node>(); foreach (var node in graph) { node.Key.DijkstraDistance = double.PositiveInfinity; } source.DijkstraDistance = 0.0d; queue.Enqueue(source); while (queue.Count != 0) { var currentNode = queue.Dequeue(); if (double.IsPositiveInfinity(currentNode.DijkstraDistance)) { break; } foreach (var neighbor in graph[currentNode]) { var potDistance = currentNode.DijkstraDistance + neighbor.Distance; if (potDistance < neighbor.Node.DijkstraDistance) { neighbor.Node.DijkstraDistance = potDistance; queue.Enqueue(neighbor.Node); } } } }
static void Main() { Node node1 = new Node(1); Node node2 = new Node(2); Node node3 = new Node(3); Node node4 = new Node(4); Node node5 = new Node(5); Node node6 = new Node(6); Node node7 = new Node(7); Node node8 = new Node(8); Node node9 = new Node(9); Node node10 = new Node(10); List<Node> nodes = new List<Node>(); nodes.Add(node1); nodes.Add(node2); nodes.Add(node3); nodes.Add(node4); nodes.Add(node5); nodes.Add(node6); nodes.Add(node7); nodes.Add(node8); nodes.Add(node9); nodes.Add(node10); Dictionary<Node, List<Connection>> graph = new Dictionary<Node, List<Connection>>() { {node1, new List<Connection> {new Connection(node2, 23), new Connection(node8, 8)} }, {node2, new List<Connection> {new Connection(node1, 23), new Connection(node4, 3), new Connection(node7, 34)} }, {node3, new List<Connection> {new Connection(node4, 6), new Connection(node8, 25), new Connection(node10, 7)} }, {node4, new List<Connection> {new Connection(node2, 3), new Connection(node3, 6)} }, {node5, new List<Connection> {new Connection(node6, 10)} }, {node6, new List<Connection> {new Connection(node5, 10)} }, {node7, new List<Connection> {new Connection(node2, 34)} }, {node8, new List<Connection> {new Connection(node1, 8), new Connection(node3, 25), new Connection(node10, 30)} }, {node9, new List<Connection> {} }, {node10, new List<Connection> {new Connection(node3, 7), new Connection(node8, 30)} }, }; Node source = node1; DijkstraAlgorithm(graph, source); for (int i = 0; i < nodes.Count; i++) { Console.Write("Distance from {0} to {1} ", source.ID, i); Console.WriteLine(nodes[i].DijkstraDistance); } }
static void DijkstraAlgorithm(Dictionary<Node, List<Connection>> graph, Node source) { PriorityQueue<Node> queue = new PriorityQueue<Node>(); foreach (var node in graph) { if (source.ID != node.Key.ID) { node.Key.DijkstraDistance = double.PositiveInfinity; queue.Enqueue(node.Key); } } source.DijkstraDistance = 0.0d; queue.Enqueue(source); while (queue.Count != 0) { Node currentNode = queue.Peek(); if (currentNode.DijkstraDistance == double.PositiveInfinity) { break; } foreach (var neighbour in graph[currentNode]) { double potDistance = currentNode.DijkstraDistance + neighbour.Distance; if (potDistance < neighbour.Node.DijkstraDistance) { neighbour.Node.DijkstraDistance = potDistance; } } queue.Dequeue(); } }
public static void DijkstraAlgorithm(Dictionary<Node, List<Edge>> graph, Node source) { var pQueue = new PriorityQueue<Node>(); source.MinDistance = 0.0; pQueue.Enqueue(source); while (pQueue.Count != 0) { Console.WriteLine(string.Join<Node>(", ", pQueue.heap)); Node currentNode = pQueue.Dequeue(); foreach (var neighbour in graph[currentNode]) { double newDist = currentNode.MinDistance + neighbour.Distance; if (newDist < neighbour.Node.MinDistance) { neighbour.Node.MinDistance = newDist; pQueue.Enqueue(neighbour.Node); } } } }
public static void Main() { int n = 12; var nodes = new Node[n]; for (int i = 0; i < n; i++) { nodes[i] = new Node(i); } var graph = new Dictionary<Node, List<Edge>> { { nodes[0], new List<Edge> { new Edge(nodes[6], 10), new Edge(nodes[8], 12), } }, { nodes[1], new List<Edge> { new Edge(nodes[4], 20), new Edge(nodes[7], 26), new Edge(nodes[9], 5), new Edge(nodes[11], 6), } }, { nodes[2], new List<Edge> { new Edge(nodes[7], 15), new Edge(nodes[8], 14), new Edge(nodes[11], 9), } }, { nodes[3], new List<Edge> { new Edge(nodes[10], 7), } }, { nodes[4], new List<Edge> { new Edge(nodes[1], 20), new Edge(nodes[5], 5), new Edge(nodes[6], 17), new Edge(nodes[11], 11), } }, { nodes[5], new List<Edge> { new Edge(nodes[4], 5), new Edge(nodes[6], 6), new Edge(nodes[8], 3), new Edge(nodes[11], 33), } }, { nodes[6], new List<Edge> { new Edge(nodes[0], 10), new Edge(nodes[4], 17), new Edge(nodes[5], 6), } }, { nodes[7], new List<Edge> { new Edge(nodes[1], 26), new Edge(nodes[2], 15), new Edge(nodes[9], 3), new Edge(nodes[11], 20), } }, { nodes[8], new List<Edge> { new Edge(nodes[0], 12), new Edge(nodes[2], 14), new Edge(nodes[5], 3), } }, { nodes[9], new List<Edge> { new Edge(nodes[1], 5), new Edge(nodes[7], 3), } }, { nodes[10], new List<Edge> { new Edge(nodes[3], 7), } }, { nodes[11], new List<Edge> { new Edge(nodes[1], 6), new Edge(nodes[2], 9), new Edge(nodes[4], 11), new Edge(nodes[5], 33), new Edge(nodes[7], 20), } } }; Node source = nodes[0]; DijkstraAlgorithm(graph, source); for (int i = 0; i < nodes.Length; i++) { Console.Write("Shortest distance [{0} -> {1}]: ", source.Id, i); double distance = nodes[i].Distance; if (double.IsPositiveInfinity(distance)) { Console.WriteLine("no path"); } else { var path = FindPath(graph, nodes[i]); var pathStr = string.Join("->", path.Select(node => node.Id)); Console.WriteLine("{0} (Path = {1})", distance, pathStr); } } }
private static List<Node> FindPath( Dictionary<Node, List<Edge>> graph, Node node) { var path = new List<Node>(); while (node != null) { path.Add(node); node = node.PreviousNode; } path.Reverse(); return path; }
public Connection(Node node, double distance) { this.Node = node; this.Distance = distance; }