public static void DijkstraAlgorithm(Dictionary<Node, List<Connection>> graph, Node source) { PriorityQueue<Node> queue = new PriorityQueue<Node>(); foreach (var item in graph) { item.Key.DijkstraDistance = long.MaxValue; } queue.Enqueue(source); source.DijkstraDistance = 0; while (queue.Count != 0) { var currentNode = queue.Dequeue(); foreach (var connection in graph[currentNode]) { var dist = connection.Distance + currentNode.DijkstraDistance; if (dist < connection.ToNode.DijkstraDistance) { connection.ToNode.DijkstraDistance = dist; queue.Enqueue(connection.ToNode); } } } }
public static void DijkstraAlgorithm(Dictionary<Node, List<Connection>> graph, Node source) { PriorityQueue<Node> queue = new PriorityQueue<Node>(); foreach (var node in graph) { node.Key.DijkstraDistance = long.MaxValue; } source.DijkstraDistance = 0; queue.Enqueue(source); while (queue.Count != 0) { Node currentNode = queue.Dequeue(); if (currentNode.DijkstraDistance == long.MaxValue) { break; } foreach (var connection in graph[currentNode]) { var potDistance = currentNode.DijkstraDistance + connection.Distance; if (potDistance < connection.ToNode.DijkstraDistance) { connection.ToNode.DijkstraDistance = potDistance; queue.Enqueue(connection.ToNode); } } } }
private void ProcessNode(Node node, List<Node> queue) { var connections = node.Connections.Where(c => queue.Contains(c.Target)); foreach (var connection in connections) { double distance = node.DistanceFromStart + connection.Distance; if (distance < connection.Target.DistanceFromStart) { connection.Target.DistanceFromStart = distance; } } }
private static void Dijkstra(Dictionary<Node, List<Edge>> map, Node source) { PriorityQueue<Node> queue = new PriorityQueue<Node>(); foreach (KeyValuePair<Node, List<Edge>> pair in map) { if (pair.Key.Index != source.Index) { queue.Enqueue(pair.Key); pair.Key.DijkstraDistance = int.MaxValue; } } source.DijkstraDistance = 0; queue.Enqueue(source); Node currentNode; while (queue.Count != 0) { currentNode = queue.Peek(); if (currentNode.DijkstraDistance == int.MaxValue) { break; } foreach (Edge edge in map[currentNode]) { int potDistance = currentNode.DijkstraDistance + edge.Distance; if (potDistance < edge.Node.DijkstraDistance) { edge.Node.DijkstraDistance = potDistance; Node nextNode = new Node(edge.Node.Index); nextNode.DijkstraDistance = potDistance; queue.Enqueue(nextNode); } } queue.Dequeue(); } }
private static int GetDistanceToHouses(Node hospital) { foreach (var node in map) { node.Key.DijkstraDistance = int.MaxValue; } hospital.DijkstraDistance = 0; var nodes = new OrderedBag<Node>(); nodes.Add(hospital); while (nodes.Count > 0) { var currentNode = nodes.RemoveFirst(); if (currentNode.DijkstraDistance == int.MaxValue) { break; } foreach (var edge in map[currentNode]) { int potentialDistance = currentNode.DijkstraDistance + edge.Distance; if (potentialDistance < edge.Destination.DijkstraDistance) { edge.Destination.DijkstraDistance = potentialDistance; nodes.Add(edge.Destination); } } } int distanceToHomes = 0; foreach (var point in map) { if (!point.Key.IsHospital && point.Key.DijkstraDistance != int.MaxValue) { distanceToHomes += point.Key.DijkstraDistance; } } return distanceToHomes; }
internal void AddConnection(Node targetNode, double distance, bool twoWay) { if (targetNode == null) { throw new ArgumentNullException("targetNode"); } if (targetNode == this) { throw new ArgumentException("Node may not connect to itself."); } if (distance <= 0) { throw new ArgumentException("Distance must be positive."); } connections.Add(new Edge(targetNode, distance)); if (twoWay) { targetNode.AddConnection(this, distance, false); } }
public void AddNode(string name) { var node = new Node(name); Nodes.Add(name, node); }
private static void Main() { string[] data = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); int streetsCount = int.Parse(data[1]); string[] hospitals = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); // Storage of the unique nodes Dictionary<int, Node> uniqueNodes = new Dictionary<int, Node>(); // Storaga of the Node-Connection pair Dictionary<Node, List<Connection>> graph = new Dictionary<Node, List<Connection>>(); for (int i = 0; i < streetsCount; i++) { string[] connection = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); int firstNode = int.Parse(connection[0]); int secondNode = int.Parse(connection[1]); int distance = int.Parse(connection[2]); if (!uniqueNodes.ContainsKey(firstNode)) { Node firstUniqueNode = new Node(firstNode); uniqueNodes.Add(firstNode, firstUniqueNode); } if (!uniqueNodes.ContainsKey(secondNode)) { Node secondUniqueNode = new Node(secondNode); uniqueNodes.Add(secondNode, secondUniqueNode); } if (!graph.ContainsKey(uniqueNodes[firstNode])) { graph.Add(uniqueNodes[firstNode], new List<Connection>()); } if (!graph.ContainsKey(uniqueNodes[secondNode])) { graph.Add(uniqueNodes[secondNode], new List<Connection>()); } graph[uniqueNodes[firstNode]].Add(new Connection(uniqueNodes[secondNode], distance)); graph[uniqueNodes[secondNode]].Add(new Connection(uniqueNodes[firstNode], distance)); } List<int> allHospitals = new List<int>(); for (int i = 0; i < hospitals.Length; i++) { int currentHospital = int.Parse(hospitals[i]); allHospitals.Add(currentHospital); uniqueNodes[currentHospital].IsHospital = true; } long minDijkstraDistance = long.MaxValue; for (int i = 0; i < allHospitals.Count; i++) { DijkstraAlgorithm(graph, uniqueNodes[allHospitals[i]]); long sum = 0; foreach (var item in uniqueNodes) { if (!item.Value.IsHospital) { sum += item.Value.DijkstraDistance; } } if (sum < minDijkstraDistance) { minDijkstraDistance = sum; } } Console.WriteLine(minDijkstraDistance); }
public Connection(long distance, Node node) { this.Distance = distance; this.Node = node; }
internal Edge(Node target, double distance) { Target = target; Distance = distance; }
static void Main(string[] args) { string pointLine = Console.ReadLine(); string[] mapPoints = pointLine.Split(' '); int totalPoints = int.Parse(mapPoints[0]); int totalConnections = int.Parse(mapPoints[1]); int totalHospitals = int.Parse(mapPoints[2]); string hospitalLine = Console.ReadLine(); string[] hospitals = hospitalLine.Split(' '); int[] hospitalNumbers = new int[totalHospitals]; //fill in hospital numbers for (int i = 0; i < totalHospitals; i++) { hospitalNumbers[i] = int.Parse(hospitals[i]); } Dictionary<int, Node> nodes = new Dictionary<int, Node>(); //fill in street connections and nodes for (int i = 0; i < totalConnections; i++) { string[] connection = Console.ReadLine().Split(' '); int firstNodeId = int.Parse(connection[0]); int secondNodeId = int.Parse(connection[1]); int distance = int.Parse(connection[2]); if (!nodes.ContainsKey(firstNodeId)) { Node firstNode = new Node(firstNodeId, long.MaxValue); nodes.Add(firstNodeId, firstNode); } if (!nodes.ContainsKey(secondNodeId)) { Node secondNode = new Node(secondNodeId, long.MaxValue); nodes.Add(secondNodeId, secondNode); } if (graph.ContainsKey(nodes[firstNodeId])) { graph[nodes[firstNodeId]].Add(new Connection(distance, nodes[secondNodeId])); } else { graph.Add(nodes[firstNodeId], new List<Connection>() { new Connection(distance, nodes[secondNodeId]) }); } if (graph.ContainsKey(nodes[secondNodeId])) { graph[nodes[secondNodeId]].Add(new Connection(distance, nodes[firstNodeId])); } else { graph.Add(nodes[secondNodeId], new List<Connection>() { new Connection(distance, nodes[firstNodeId]) }); } } //test proper input generation //foreach (var item in graph) //{ // Console.Write("Node: {0}, connects to: ", item.Key.PointId); // foreach (var connection in item.Value) // { // Console.Write("node {0}, with distance {1}", connection.Node.PointId, connection.Distance); // } // Console.WriteLine(); //} long bestSum = long.MaxValue; for (int i = 0; i < hospitalNumbers.Length; i++) { long currentSum = 0; DijkstraAlgorithm(nodes[hospitalNumbers[i]]); //get the sum of all nodes that are not hospitals foreach (var item in graph) { if (!hospitalNumbers.Contains(item.Key.PointId)) { currentSum += item.Key.DijkstraDistance; } } if (currentSum < bestSum) { bestSum = currentSum; } } Console.WriteLine(bestSum); }
public static void DijkstraAlgorithm(Node source) { var queue = new OtherPriorityQueue<Node>(); foreach (var item in graph) { if (source.PointId != item.Key.PointId) { item.Key.DijkstraDistance = long.MaxValue; } } queue.Enqueue(source); source.DijkstraDistance = 0; while (queue.Count != 0) { var currentNode = queue.Dequeue(); foreach (var connection in graph[currentNode]) { var potDistance = connection.Distance + currentNode.DijkstraDistance; if (potDistance < connection.Node.DijkstraDistance) { connection.Node.DijkstraDistance = potDistance; queue.Enqueue(connection.Node); } } } }
public static void Dijkstra(Dictionary<Node, List<Edge>> graph, Node source) { BinaryHeapMin<Node> heap = new BinaryHeapMin<Node>(); foreach (var node in graph) { node.Key.DijkstraDistance = int.MaxValue; } source.DijkstraDistance = 0; heap.Add(source); while (heap.Count > 0) { Node currentNode = heap.RemoveTop(); if (currentNode.DijkstraDistance == int.MaxValue) { break; } foreach (var edge in graph[currentNode]) { var potDistance = currentNode.DijkstraDistance + edge.Distance; if (potDistance < edge.Target.DijkstraDistance) { //first calculate dijkstra and only after that add to heap to avoid the need of heapifying the heap edge.Target.DijkstraDistance = potDistance; heap.Add(edge.Target); } } } }