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);
}
}
}
}
