/// <summary>
/// The Dijkstra's algorithm.
/// </summary>
private void _dijkstra()
{
while (!_minPriorityQueue.IsEmpty)
{
var currentVertex = _minPriorityQueue.DequeueMin();
var currentVertexIndex = _nodesToIndices[currentVertex];
var outgoingEdges = _graph.OutgoingEdges(currentVertex);
foreach (var outgoingEdge in outgoingEdges)
{
var adjacentIndex = _nodesToIndices[outgoingEdge.Destination];
var delta = _distances[currentVertexIndex] != Infinity ? _distances[currentVertexIndex] + outgoingEdge.Weight : Infinity;
if (delta < _distances[adjacentIndex])
{
_distances[adjacentIndex] = delta;
_predecessors[adjacentIndex] = currentVertexIndex;
if (_minPriorityQueue.Contains(outgoingEdge.Destination))
{
_minPriorityQueue.UpdatePriority(outgoingEdge.Destination, delta);
}
else
{
_minPriorityQueue.Enqueue(outgoingEdge.Destination, delta);
}
}
}
}
}
public static IEnumerable <Edge <T> > DijkstraShortestPath <T>(this IGraph <T> graph, T startVertex, T finishVertex) where T : IEquatable <T>
{
var currentVertex = startVertex;
var weigths = new MinPriorityQueue <Weight <T> >();
var paths = new Dictionary <T, Path <T> >
{
{ startVertex, new Path <T> {
Weight = 0.0, Edges = new List <Edge <T> >()
} }
};
while (paths.Count < graph.VertexCount)
{
foreach (var edge in graph.EdgesOf(currentVertex))
{
if (edge.Weight < 0)
{
throw new ArgumentOutOfRangeException(
"Edge.Weight", edge.Weight,
"Dijkstra's algorithm for shortest paths does not support negative weights.");
}
if (!paths.ContainsKey(edge.Target))
{
weigths.Enqueue(new Weight <T>
{
Edge = edge,
PathWeight = paths[edge.Source].Weight + edge.Weight
});
}
}
Weight <T> smallest;
do
{
// skip obsolete edges
smallest = weigths.DequeueMin();
} while (paths.ContainsKey(smallest.Edge.Target));
var pathToSource = paths[smallest.Edge.Source];
var path = new List <Edge <T> >(pathToSource.Edges);
path.Add(smallest.Edge);
if (smallest.Edge.Target.Equals(finishVertex))
{
return(path);
}
currentVertex = smallest.Edge.Target;
paths.Add(smallest.Edge.Target, new Path <T> {
Weight = smallest.PathWeight, Edges = path
});
}
return(new Edge <T> [0]);
}
/************************************************************************************************************/
/// <summary>
/// The Dijkstra's algorithm.
/// </summary>
private void _dijkstra(TGraph graph, TVertex source)
{
var minPQ = new MinPriorityQueue <TVertex, decimal>((uint)_verticesCount);
var srcIndex = _nodesToIndices[source];
_srcIndex = srcIndex;
_distances[srcIndex] = 0;
minPQ.Enqueue(source, _distances[srcIndex]);
// Main loop
while (!minPQ.IsEmpty)
{
var current = minPQ.DequeueMin(); // get vertex with min weight
var currentIndex = _nodesToIndices[current]; // get its index
var edges = graph.OutgoingEdges(current) as IEnumerable <WeightedEdge <TVertex> >; // get its outgoing weighted edges
foreach (var edge in edges)
{
var adjacentIndex = _nodesToIndices[edge.Destination];
// calculate a new possible weighted path if the edge weight is less than infinity
var delta = Infinity;
if (edge.Weight < Infinity && _distances[currentIndex] + edge.Weight < Infinity) // Handles overflow
{
delta = _distances[currentIndex] + edge.Weight;
}
// Relax the edge
// if check is true, a shorter path is found from current to adjacent
if (delta < _distances[adjacentIndex])
{
_edgeTo[adjacentIndex] = edge;
_distances[adjacentIndex] = delta;
_predecessors[adjacentIndex] = currentIndex;
// decrease priority with a new distance if it exists; otherwise enqueque it
if (minPQ.Contains(edge.Destination))
{
minPQ.UpdatePriority(edge.Destination, delta);
}
else
{
minPQ.Enqueue(edge.Destination, delta);
}
}
} //end-foreach
} //end-while
}
public void MinPriorityQueue_SingleEnqueueDequeueTest()
{
string test = "test";
var queue = new MinPriorityQueue <string>();
queue.Enqueue(test);
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(1, queue.Size);
var dequeued = queue.DequeueMin();
Assert.IsTrue(queue.IsEmpty);
Assert.AreEqual(0, queue.Size);
Assert.AreEqual(test, dequeued);
}
/************************************************************************************************************/
/// <summary>
/// The Dijkstra's algorithm.
/// </summary>
private void _dijkstra(TGraph graph, TVertex source)
{
var minPQ = new MinPriorityQueue <TVertex, long>((uint)_verticesCount);
int srcIndex = _nodesToIndices[source];
_distances[srcIndex] = 0;
// Add all vertices to the queue
foreach (var vertex in _nodesToIndices)
{
minPQ.Enqueue(vertex.Key, _distances[vertex.Value]);
}
// Main loop
while (!minPQ.IsEmpty)
{
var current = minPQ.DequeueMin(); // get vertex with min weight
var currentIndex = _nodesToIndices[current]; // get its index
var edges = graph.OutgoingEdges(current); // get its outgoing weighted edges
foreach (var edge in edges)
{
var adjacentIndex = _nodesToIndices[edge.Destination];
var delta = _distances[currentIndex] + edge.Weight; // calculate a new possible weighted path
if (delta < _distances[adjacentIndex]) // if true, a shorter path is found from current to adjacent
{
_edgeTo[adjacentIndex] = edge;
_distances[adjacentIndex] = delta;
_predecessors[adjacentIndex] = currentIndex;
minPQ.UpdatePriority(edge.Destination, delta); // decrease priority with a new edge weight
}
}//end-foreach
}//end-while
}
// GET: /<controller>/
public IActionResult Index()
{
string result = string.Empty;
// KEYED PRIORITY QUEUE
PriorityQueue <int, int, int> keyedPriorityQueue = new PriorityQueue <int, int, int>(10);
for (int i = 0; i < 20; ++i)
{
keyedPriorityQueue.Enqueue(i, i, (i / 3) + 1);
}
result = result + "Enqueue Keys: ";
foreach (var key in keyedPriorityQueue.Keys)
{
result = result + key + ",";
}
var keyedPQHighest = keyedPriorityQueue.Dequeue();
result = result + "\nAfter Dequeue, Keyed PQ Highest = " + keyedPQHighest + "\n\n";
// Integer-index priority-queue
string alphabet = "abcdefghijklmnopqrstuvwxyz";
result = result + "Alphabets: " + "abcdefghijklmnopqrstuvwxyz" + "\n";
MinPriorityQueue <string, int> priorityQueue = new MinPriorityQueue <string, int>((uint)alphabet.Length);
for (int i = 0; i < alphabet.Length; ++i)
{
priorityQueue.Enqueue(alphabet[i].ToString(), (i / 3) + 1);
}
var PQMin = priorityQueue.DequeueMin();
result = result + "PQ Min = " + PQMin + "\n\n";
// Processes with priorities
MinPriorityQueue <Process, int> sysProcesses = new MinPriorityQueue <Process, int>();
var process1 = new Process(
id: 432654,
action: new Action(() => System.Console.Write("I am Process #1.\r\n1 + 1 = " + (1 + 1))),
desc: "Process 1");
result = result + "Id: " + process1.Id + "\nI am Process #1: 1 + 1 = " + (1 + 1) + "\n\n";
var process2 = new Process(
id: 123456,
action: new Action(() => System.Console.Write("Hello, World! I am Process #2")),
desc: "Process 2");
result = result + "Id: " + process2.Id + "\nHello, World! I am Process #2" + "\n\n";
var process3 = new Process(
id: 345098,
action: new Action(() => System.Console.Write("I am Process #3")),
desc: "Process 3");
result = result + "Id: " + process3.Id + "\nI am Process #3" + "\n\n";
var process4 = new Process(
id: 109875,
action: new Action(() => System.Console.Write("I am Process #4")),
desc: "Process 4");
result = result + "Id: " + process4.Id + "\nI am Process #4" + "\n\n";
var process5 = new Process(
id: 13579,
action: new Action(() => System.Console.Write("I am Process #5")),
desc: "Process 5");
result = result + "Id: " + process5.Id + "\nI am Process #5" + "\n\n";
var process6 = new Process(
id: 24680,
action: new Action(() => System.Console.Write("I am Process #6")),
desc: "Process 6");
result = result + "Id: " + process6.Id + "\nI am Process #6" + "\n\n";
sysProcesses.Enqueue(process1, 1);
sysProcesses.Enqueue(process2, 10);
sysProcesses.Enqueue(process3, 5);
sysProcesses.Enqueue(process4, 7);
sysProcesses.Enqueue(process5, 3);
sysProcesses.Enqueue(process6, 6);
var leastPriorityProcess = sysProcesses.PeekAtMinPriority();
result = result + "First, Least Priority Process.Id = " + leastPriorityProcess.Id + "\n";
sysProcesses.DequeueMin();
leastPriorityProcess = sysProcesses.PeekAtMinPriority();
result = result + "After the second DequeueMin(), Least Priority Process.Id = " + leastPriorityProcess.Id + "\n";
sysProcesses.DequeueMin();
leastPriorityProcess = sysProcesses.PeekAtMinPriority();
result = result + "After the third DequeueMin(), Least Priority Process.Id = " + leastPriorityProcess.Id + "\n";
sysProcesses.DequeueMin();
leastPriorityProcess = sysProcesses.PeekAtMinPriority();
result = result + "After the forth DequeueMin(), Least Priority Process.Id = " + leastPriorityProcess.Id + "\n";
leastPriorityProcess.Action();
HtmlString html = StringHelper.GetHtmlString(result);
return(View(html));
}
public void MinPriorityQueue_DequeueMinFromEmptyQueueTest()
{
var queue = new MinPriorityQueue <string>();
queue.DequeueMin();
}
public void MinPriorityQueue_MultipleEnqueueDequeueTest()
{
var testData = new int[] { 12, 0, 3, 9, 1, 3, 4, 4, 5, 2, 13, 7, 8, 3, 11, 14, 15 };
var queue = new MinPriorityQueue <int>();
foreach (var item in testData)
{
queue.Enqueue(item);
}
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length, queue.Size);
var dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 1, queue.Size);
Assert.AreEqual(0, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 2, queue.Size);
Assert.AreEqual(1, dequeued);
dequeued = queue.Min;
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 2, queue.Size);
Assert.AreEqual(2, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 3, queue.Size);
Assert.AreEqual(2, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 4, queue.Size);
Assert.AreEqual(3, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 5, queue.Size);
Assert.AreEqual(3, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 6, queue.Size);
Assert.AreEqual(3, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 7, queue.Size);
Assert.AreEqual(4, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 8, queue.Size);
Assert.AreEqual(4, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 9, queue.Size);
Assert.AreEqual(5, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 10, queue.Size);
Assert.AreEqual(7, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 11, queue.Size);
Assert.AreEqual(8, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 12, queue.Size);
Assert.AreEqual(9, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 13, queue.Size);
Assert.AreEqual(11, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 14, queue.Size);
Assert.AreEqual(12, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 15, queue.Size);
Assert.AreEqual(13, dequeued);
dequeued = queue.DequeueMin();
Assert.IsFalse(queue.IsEmpty);
Assert.AreEqual(testData.Length - 16, queue.Size);
Assert.AreEqual(14, dequeued);
dequeued = queue.DequeueMin();
Assert.IsTrue(queue.IsEmpty);
Assert.AreEqual(0, queue.Size);
Assert.AreEqual(15, dequeued);
}
public static void DoTest()
{
//
// KEYED PRIORITY QUEUE
PriorityQueue <int, int, int> keyedPriorityQueue = new PriorityQueue <int, int, int> (10);
for (int i = 0; i < 20; ++i)
{
keyedPriorityQueue.Enqueue(i, i, (i / 3) + 1);
}
var keyedPQHighest = keyedPriorityQueue.Dequeue();
Debug.Assert(keyedPQHighest == 18, "Wrong node!");
//
// Integer-index priority-queue
string alphabet = "abcdefghijklmnopqrstuvwxyz";
MinPriorityQueue <string, int> priorityQueue = new MinPriorityQueue <string, int> ((uint)alphabet.Length);
for (int i = 0; i < alphabet.Length; ++i)
{
priorityQueue.Enqueue(alphabet[i].ToString(), (i / 3) + 1);
}
var PQMin = priorityQueue.DequeueMin();
Debug.Assert(PQMin == "a", "Wrong node!");
//
// Processes with priorities
MinPriorityQueue <Process, int> sysProcesses = new MinPriorityQueue <Process, int>();
var process1 = new Process(
id: 432654,
action: new Action(() => System.Console.Write("I am Process #1.\r\n1 + 1 = " + (1 + 1))),
desc: "Process 1");
var process2 = new Process(
id: 123456,
action: new Action(() => System.Console.Write("Hello, World! I am Process #2")),
desc: "Process 2");
var process3 = new Process(
id: 345098,
action: new Action(() => System.Console.Write("I am Process #3")),
desc: "Process 3");
var process4 = new Process(
id: 109875,
action: new Action(() => System.Console.Write("I am Process #4")),
desc: "Process 4");
var process5 = new Process(
id: 13579,
action: new Action(() => System.Console.Write("I am Process #5")),
desc: "Process 5");
var process6 = new Process(
id: 24680,
action: new Action(() => System.Console.Write("I am Process #6")),
desc: "Process 6");
sysProcesses.Enqueue(process1, 1);
sysProcesses.Enqueue(process2, 10);
sysProcesses.Enqueue(process3, 5);
sysProcesses.Enqueue(process4, 7);
sysProcesses.Enqueue(process5, 3);
sysProcesses.Enqueue(process6, 6);
var leastPriorityProcess = sysProcesses.PeekAtMinPriority();
Debug.Assert(leastPriorityProcess.Id == process1.Id, "Wrong process!");
sysProcesses.DequeueMin();
leastPriorityProcess = sysProcesses.PeekAtMinPriority();
Debug.Assert(leastPriorityProcess.Id == process5.Id, "Wrong process!");
sysProcesses.DequeueMin();
leastPriorityProcess = sysProcesses.PeekAtMinPriority();
Debug.Assert(leastPriorityProcess.Id == process3.Id, "Wrong process!");
sysProcesses.DequeueMin();
leastPriorityProcess = sysProcesses.PeekAtMinPriority();
Debug.Assert(leastPriorityProcess.Id == process6.Id, "Wrong process!");
leastPriorityProcess.Action();
}
