public void TestPriorityQueue()
{
int operationsCount = 100000;
Random rand = new Random(0);
PriorityQueue<double> queue = new PriorityQueue<double>();
for (int op = 0; op < operationsCount; ++op)
{
int opType = rand.Next(0, 2);
if (opType == 0) // Enqueue
{
double item = (100.0 - 1.0) * rand.NextDouble() + 1.0;
queue.Enqueue(item);
Assert.IsTrue(queue.IsConsistent(), "Test fails after enqueue operation # " + op);
}
else // Dequeue
{
if (queue.Count > 0)
{
double item = queue.Dequeue();
Assert.IsTrue(queue.IsConsistent(), "Test fails after dequeue operation # " + op);
}
}
}
}
static void Main()
{
PriorityQueue<int> queue = new PriorityQueue<int>();
queue.Enqueue(10);
queue.Enqueue(3);
queue.Enqueue(14);
queue.Enqueue(12);
queue.Enqueue(5);
queue.Enqueue(2);
Console.WriteLine("Printing the queue");
foreach (var item in queue)
{
Console.WriteLine(item);
}
Console.WriteLine("Dequeue {0}", queue.Dequeue());
Console.WriteLine("Dequeue {0}", queue.Dequeue());
Console.WriteLine("Printing the queue again");
foreach (var item in queue)
{
Console.WriteLine(item);
}
}
public void Enqueue_InsertLowMediumMediumHighPriorityElements_GetElementsBackInOrder()
{
IQueue queue = new PriorityQueue(MaxCapacity);
queue.Enqueue(VALID_ELEMENT_CAM_ON, QueuePriorities.Low);
queue.Enqueue(VALID_ELEMENT_MOVEMENT, QueuePriorities.Medium);
queue.Enqueue(VALID_ELEMENT_CAM_ON, QueuePriorities.Medium);
queue.Enqueue(VALID_ELEMENT_MOVEMENT, QueuePriorities.High);
string expected1 = VALID_ELEMENT_MOVEMENT;
string expected2 = VALID_ELEMENT_CAM_ON;
string expected3 = VALID_ELEMENT_MOVEMENT;
string expected4 = VALID_ELEMENT_CAM_ON;
string actual1;
string actual2;
string actual3;
string actual4;
bool result1 = queue.TryDequeue(out actual1);
bool result2 = queue.TryDequeue(out actual2);
bool result3 = queue.TryDequeue(out actual3);
bool result4 = queue.TryDequeue(out actual4);
Assert.AreEqual(expected1, actual1);
Assert.AreEqual(expected2, actual2);
Assert.AreEqual(expected3, actual3);
Assert.AreEqual(expected4, actual4);
}
private static void PrintNumbersOnConsole(PriorityQueue<int> numbers)
{
foreach (int number in numbers)
{
Console.WriteLine(number);
}
}
/* 1 Implement a class PriorityQueue<T> based
* on the data structure "binary heap".
* */
static void Main(string[] args)
{
var heap = new Heap<int>();
heap.Add(1);
heap.Add(2);
heap.Add(3);
Debug.Assert(heap.SameContents(new[] { 1, 2, 3 }));
Console.WriteLine(string.Join(",", heap));
Debug.Assert(heap.ChopHead() == 3);
Debug.Assert(heap.ChopHead() == 2);
Debug.Assert(heap.ChopHead() == 1);
Debug.Assert(heap.IsEmpty);
// higher string means lower priority
var pqueue = new PriorityQueue<string, string>((s1, s2) => -s1.CompareTo(s2));
pqueue.Enqueue("18:00", "Buy food");
pqueue.Enqueue("06:00", "Walk dog");
pqueue.Enqueue("21:00", "Do homework");
pqueue.Enqueue("09:00", "Go to work");
pqueue.Enqueue("21:00", "Drink beer");
Debug.Assert(pqueue.Count == 5);
Debug.Assert(pqueue.Dequeue() == "Walk dog");
Debug.Assert(pqueue.Dequeue() == "Go to work");
Debug.Assert(pqueue.Dequeue() == "Buy food");
Debug.Assert(new[] { "Do homework", "Drink beer" }.Contains(pqueue.Dequeue()));
Debug.Assert(new[] { "Do homework", "Drink beer" }.Contains(pqueue.Dequeue()));
}
public static void FindMinimalDistance(Dictionary<Node, List<Connection>> graph, Node source)
{
var queue = new PriorityQueue<Node>();
foreach (var node in graph)
node.Key.DijkstraDistance = long.MaxValue; // double.PositiveInfinity;
queue.AddFirst(source);
source.DijkstraDistance = 0;
while (queue.Count != 0)
{
var currentNode = queue.RemoveFirst();
// if (currentNode.DijkstraDistance == long.MaxValue) break;
foreach (var neighbour in graph[currentNode])
{
var potDistance = neighbour.Distance + currentNode.DijkstraDistance;
if (potDistance < neighbour.ToNode.DijkstraDistance)
{
neighbour.ToNode.DijkstraDistance = potDistance;
queue.AddFirst(neighbour.ToNode);
}
}
}
}
public void CorrectPriorityTest1()
{
PriorityQueue<int> queue = new PriorityQueue<int>();
queue.Enqueue(-12);
queue.Enqueue(512);
queue.Enqueue(77);
queue.Enqueue(-1);
queue.Enqueue(82);
queue.Enqueue(92);
queue.Enqueue(-111);
queue.Enqueue(-151);
queue.Enqueue(512);
queue.Enqueue(55);
Assert.AreEqual(10, queue.Count);
Assert.AreEqual(512, queue.Dequeue());
Assert.AreEqual(512, queue.Dequeue());
Assert.AreEqual(92, queue.Dequeue());
Assert.AreEqual(82, queue.Dequeue());
Assert.AreEqual(77, queue.Dequeue());
Assert.AreEqual(55, queue.Dequeue());
Assert.AreEqual(-1, queue.Dequeue());
Assert.AreEqual(-12, queue.Dequeue());
Assert.AreEqual(-111, queue.Dequeue());
Assert.AreEqual(-151, queue.Dequeue());
}
public void EnqueueAndDequeueReverseOrder()
{
PriorityQueue queue = new PriorityQueue();
Assert.False(queue.IsDataAvailable);
queue.Enqueue(new PriorityQueueEntry(Priority.Pri7));
queue.Enqueue(new PriorityQueueEntry(Priority.Pri4));
queue.Enqueue(new PriorityQueueEntry(Priority.Pri3));
Assert.True(queue.IsDataAvailable);
PriorityQueueEntry output;
Assert.True(queue.TryDequeue(out output));
Assert.NotNull(output);
Assert.Equal(Priority.Pri3, output.Priority);
Assert.True(queue.IsDataAvailable);
Assert.True(queue.TryDequeue(out output));
Assert.NotNull(output);
Assert.Equal(Priority.Pri4, output.Priority);
Assert.True(queue.IsDataAvailable);
Assert.True(queue.TryDequeue(out output));
Assert.NotNull(output);
Assert.Equal(Priority.Pri7, output.Priority);
Assert.False(queue.IsDataAvailable);
}
public static Path<Tile> FindPath(
Tile start,
Tile destination)
{
var closed = new HashSet<Tile>();
var queue = new PriorityQueue<double, Path<Tile>>();
queue.Enqueue(0, new Path<Tile>(start));
while (!queue.IsEmpty)
{
var path = queue.Dequeue();
if (closed.Contains(path.LastStep))
continue;
if (path.LastStep.Equals(destination))
return path;
closed.Add(path.LastStep);
foreach (Tile n in path.LastStep.Neighbours)
{
double d = distance(path.LastStep, n);
var newPath = path.AddStep(n, d);
queue.Enqueue(newPath.TotalCost + estimate(n, destination),
newPath);
}
}
return null;
}
static void Main()
{
Console.WriteLine("Creating an instance of the custom PriorityQueue class and adding 8 integers to it in non-increasing randomized order.");
var priorityQueue = new PriorityQueue<int>();
priorityQueue.Enqueue(5);
priorityQueue.Enqueue(3);
priorityQueue.Enqueue(2);
priorityQueue.Enqueue(5);
priorityQueue.Enqueue(15);
priorityQueue.Enqueue(6);
priorityQueue.Enqueue(0);
priorityQueue.Enqueue(-8);
Console.WriteLine("Printing the queue:");
PrintQueue(priorityQueue);
Console.WriteLine("Dequeuing and displaying the first 5 elements");
for (int i = 0; i < 5; i++)
{
Console.WriteLine("Dequeuing the number {0}", priorityQueue.Dequeue());
}
Console.WriteLine("Printing the queue after the removal:");
PrintQueue(priorityQueue);
Console.WriteLine("Adding 5 more integers to the queue in non-increasing randomized order.");
priorityQueue.Enqueue(9);
priorityQueue.Enqueue(20);
priorityQueue.Enqueue(13);
priorityQueue.Enqueue(2);
priorityQueue.Enqueue(7);
Console.WriteLine("Printing the queue after the addition:");
PrintQueue(priorityQueue);
}
private static void Main()
{
var items = new[] { 2, 6, 3, 2, 1, 7, 4, 9, 5, 1, 8 };
Console.WriteLine("Items: [{0}]", string.Join(", ", items));
// Priority queue of integers, where a lower number means higher priority
var queue = new PriorityQueue<int>();
// Add each item to the priority queue and
// check if the item with the highest priority is at the top of the queue
var minItem = int.MaxValue;
foreach (var item in items)
{
queue.Enqueue(item);
minItem = Math.Min(item, minItem);
Debug.Assert(queue.Peek() == minItem);
}
// Now check if after each dequeue, the items come out ranked by priority
var sorted = new List<int>();
while (queue.Count > 0)
{
sorted.Add(queue.Dequeue());
}
// Items should be sorted in ascending order
Console.WriteLine("Queue items: [{0}]", string.Join(", ", sorted));
}
static ICollection<Node> PrimAlgorithm(Node startNode)
{
var mst = new List<Node>();
PriorityQueue queue = new PriorityQueue();
startNode.Used = true;
mst.Add(startNode);
foreach (var connection in neighbourhood[startNode])
{
queue.Enqueue(connection);
}
while (mst.Count != houses.Count)
{
var current = queue.Dequeue();
current.ToNode.Used = true;
mst.Add(current.ToNode);
foreach (var connection in neighbourhood[current.ToNode])
{
if (!connection.ToNode.Used)
{
queue.Enqueue(connection);
}
}
}
return mst;
}
public static void DijkstraAlgorithm(Graph graph, Node source)
{
foreach (var node in graph)
{
node.MinDistance = double.PositiveInfinity;
}
source.MinDistance = 0;
var pQueue = new PriorityQueue<Node>();
pQueue.Enqueue(source);
while (pQueue.Count != 0)
{
Node currentNode = pQueue.Dequeue();
foreach (var neighbour in graph[currentNode.Id].Neighbors)
{
double newDist = currentNode.MinDistance + neighbour.Distance;
if (newDist < neighbour.Node.MinDistance)
{
neighbour.Node.MinDistance = newDist;
pQueue.Enqueue(neighbour.Node);
}
}
}
}
public void TestEnqueueDequeue()
{
PriorityQueue<int> queue = new PriorityQueue<int>();
queue.enqueueWithPriority (16,4);
queue.enqueueWithPriority (14,5);
queue.enqueueWithPriority (25,3);
queue.enqueueWithPriority (17,4);
Assert.AreEqual (queue.dequeue (), 14);
Assert.AreEqual (queue.dequeue (), 16);
Assert.AreEqual (queue.dequeue (), 17);
Assert.AreEqual (queue.dequeue (), 25);
queue.enqueueWithPriority(11,1);
Assert.AreEqual (queue.dequeue (), 11);
try {
Console.Out.WriteLine("Attempting to dequeue an empty queue.");
queue.dequeue();
Console.Error.WriteLine("FAIL: System.InvalidOperationExcepti"+
"on was not thrown when dequeing an empty queue");
Assert.IsTrue(false);
} catch (System.InvalidOperationException e)
{
Console.Out.WriteLine("PASS: System.InvalidOperationException"+
" thrown as expected: "+e.Message);
Assert.IsTrue(true,"Exception thrown");
}
}
static void Main(string[] args)
{
IQueue CommanderDispatcherMessageQueue = new PriorityQueue(30);
IQueue DispatcherSerialMessageQueue = new PriorityQueue(30);
//IQueue SerialStatusMessageQueue = new PriorityQueue(30);
// IQueue StatusCommanderMessageQueue = new PriorityQueue(30);
//IQueue MicrocontrollerCommanderMessageBox = new PriorityQueue(30);
Thread dispatcher = new Thread(() => Dispatcher(CommanderDispatcherMessageQueue));
//Thread serialManager = new Thread(() => SerialManager(DispatcherSerialMessageQueue, MicrocontrollerCommanderMessageBox));
//Thread statusUpdater = new Thread(() => StatusUpdater(SerialStatusMessageQueue));
//Thread commandSender = new Thread(() => CommandSender(MicrocontrollerCommanderMessageBox));
RoverCameraFactory.GetInstance().Initialize(Properties.NetworkSettings.Default.OperatorIPAddress, Properties.NetworkSettings.Default.CameraBasePort);
dispatcher.Start();
//serialManager.Start();
//statusUpdater.Start();
// commandSender.Start();
//Start the commands listener
var commandsListener = new GuardedMessageListener(
Properties.NetworkSettings.Default.CommandsPort,
CommanderDispatcherMessageQueue,
Properties.NetworkSettings.Default.OperatorIPAddress,
new WatchDog());
commandsListener.StartListening();
}
public static void FindMinimalPaths(Dictionary<Node, List<Street>> graph, Node source)
{
PriorityQueue<Node> queue = new PriorityQueue<Node>();
foreach (var node in graph)
{
if (source.ID != node.Key.ID)
{
node.Key.DijkstraDistance = ulong.MaxValue;
}
}
source.DijkstraDistance = 0;
queue.Enqueue(source);
while (queue.Count != 0)
{
Node currentNode = queue.Dequeue();
foreach (var neighbour in graph[currentNode])
{
ulong potDistance = currentNode.DijkstraDistance + neighbour.Distance;
if (potDistance < neighbour.Node.DijkstraDistance)
{
neighbour.Node.DijkstraDistance = potDistance;
// adds only modified elements in the queue
// thus reordering the queue after each iteration is avoided
queue.Enqueue(neighbour.Node);
}
}
}
}
static void Main()
{
var bag = new PriorityQueue<Car>();
var opel = new Car
{
Model = "Opel",
Price = 1000
};
var mercedes = new Car
{
Model = "Mercedes",
Price = 5000
};
var citroen = new Car
{
Model = "Citroen",
Price = 3000
};
bag.Enqueue(opel);
bag.Enqueue(mercedes);
bag.Enqueue(citroen);
while(bag.Count > 0)
{
var car = bag.Dequeue();
Console.WriteLine("{0} -> {1}",car.Model, car.Price);
}
}
static void Main(string[] args)
{
PriorityQueue queue = new PriorityQueue();
queue.Enqueue("Name1", Priority.Low);
queue.Enqueue("Name2", Priority.Low);
queue.Enqueue("Name3", Priority.Low);
queue.Enqueue("Name4", Priority.Low);
queue.Enqueue("Name5", Priority.Low);
queue.Enqueue("Name6", Priority.Low);
queue.Enqueue("Name7", Priority.Low);
queue.Enqueue("Name8", Priority.Low);
queue.Enqueue("Name9", Priority.Low);
Console.WriteLine("There are " + queue.Length + " people in line.");
Console.WriteLine("Person in front: " + queue.PeekAtFrontName() + " with priority " + queue.PeekAtFrontPriority());
queue.Dequeue();
Console.WriteLine("Person in front: " + queue.PeekAtFrontName() + " with priority " + queue.PeekAtFrontPriority());
queue.Dequeue();
Console.WriteLine("Person in front: " + queue.PeekAtFrontName() + " with priority " + queue.PeekAtFrontPriority());
queue.Enqueue("Name10", Priority.Medium);
Console.WriteLine("Person in front: " + queue.PeekAtFrontName() + " with priority " + queue.PeekAtFrontPriority());
queue.Enqueue("Name11", Priority.Medium);
Console.WriteLine("Person in front: " + queue.PeekAtFrontName() + " with priority " + queue.PeekAtFrontPriority());
queue.Dequeue();
queue.Enqueue("Dad", Priority.High);
Console.WriteLine("Person in front: " + queue.PeekAtFrontName() + " with priority " + queue.PeekAtFrontPriority());
}
public void CorrectPriorityTest2()
{
PriorityQueue<int> queue = new PriorityQueue<int>();
queue.Enqueue(4);
queue.Enqueue(1);
queue.Enqueue(3);
queue.Enqueue(2);
queue.Enqueue(16);
queue.Enqueue(9);
queue.Enqueue(10);
queue.Enqueue(14);
queue.Enqueue(8);
queue.Enqueue(7);
Assert.AreEqual(10, queue.Count);
Assert.AreEqual(16, queue.Dequeue());
Assert.AreEqual(14, queue.Dequeue());
Assert.AreEqual(10, queue.Dequeue());
Assert.AreEqual(9, queue.Dequeue());
Assert.AreEqual(8, queue.Dequeue());
Assert.AreEqual(7, queue.Dequeue());
Assert.AreEqual(4, queue.Dequeue());
Assert.AreEqual(3, queue.Dequeue());
Assert.AreEqual(2, queue.Dequeue());
Assert.AreEqual(1, queue.Dequeue());
}
//-------------------------------------Movement-----------------------------------------//
// A* algorithm to find shortest path to desired tile.
private Path<Tile> findShortestPath(Tile start, Tile end)
{
PriorityQueue<int, Path<Tile>> open = new PriorityQueue<int, Path<Tile>>();
HashSet<Tile> closed = new HashSet<Tile>();
open.Enqueue(0, new Path<Tile>(start));
int cost = 1;
while (!open.isEmpty())
{
var path = open.Dequeue();
if (closed.Contains(path.LastStep))
{
continue;
}
if (path.LastStep.Equals(end))
{
return path;
}
closed.Add(path.LastStep);
foreach (Tile t in path.LastStep.connectedTiles)
{
if (t.isBlocked)
{
closed.Add(t);
continue;
}
var newPath = path.AddStep(t, cost);
open.Enqueue(newPath.TotalCost, newPath);
}
}
return null;
}
public Route GetShortestPath(Vertex from, Vertex to)
{
ResetExploration();
var queue = new PriorityQueue<double, Route>();
queue.Enqueue(0, new Route { @from });
while (!queue.IsEmpty)
{
var route = queue.Dequeue();
if (route.Last().IsExplored)
continue;
if (route.Last().Equals(to))
return route;
route.Last().IsExplored = true;
foreach (Edge n in route.Last().AdjacentEdges)
{
var newRoute = route.Clone();
newRoute.Add(n.Tail);
queue.Enqueue(newRoute.Cost, newRoute);
}
}
return null;
}
public void SimpleWithPriority()
{
var priorityQueue = new PriorityQueue<string, int>(PriorityQueueType.Minimum);
int priority;
priorityQueue.Enqueue("g", 6);
var item = priorityQueue.Peek(out priority);
Assert.AreEqual(item, "g");
Assert.AreEqual(priority, 6);
Assert.AreEqual(priorityQueue.Count, 1);
priorityQueue.Enqueue("h", 5);
item = priorityQueue.Peek(out priority);
Assert.AreEqual(item, "h");
Assert.AreEqual(priority, 5);
Assert.AreEqual(priorityQueue.Count, 2);
priorityQueue.Enqueue("i", 7);
item = priorityQueue.Peek(out priority);
Assert.AreEqual(item, "h");
Assert.AreEqual(priority, 5);
Assert.AreEqual(priorityQueue.Count, 3);
}
public PriorityQueue<IHearable> getObjectsObservableBy(IHearing listener)
{
//Brute force approach = O(n)
//For all hearing objects it's O(m*n) ~ Acceptable.
PriorityQueue<IHearable> queue = new PriorityQueue<IHearable>(true);
int i;
IHearable target;
for (i=0;i<hearableObjects.Count;++i)
{
double distanceSquared,priority; //Hopefully this will be optimized out.
target = hearableObjects[i];
//Calculates Distance^2
distanceSquared = (listener.getLocation() - target.getLocation()).sqrMagnitude;
//Store in variable for use as queue priority
priority = target.getVolume().volumeFromDistanceSquared(distanceSquared).Intensity;
//Put in queue if louder than hearing threshold.
//Debug.Log(Volume.fromIntensity(priority).Decibels + " " + target.getGameObject().name);
if (priority >= listener.getHearingThreshold().Intensity)
{
//Debug.Log(Volume.fromIntensity(priority).Decibels + " " + target.getGameObject().name);
queue.enqueueWithPriority(target,priority);
}
}
return queue;
}
/// <summary>Returns a synchronized wrapper around the queue.</summary>
/// <param name="queue">The queue to be synchronized.</param>
/// <returns>A synchronized priority queue.</returns>
public static PriorityQueue Synchronize(PriorityQueue queue)
{
// Return the queue if it is already synchronized. Otherwise, wrap it
// with a synchronized wrapper.
if (queue is SyncPriorityQueue) return queue;
return new SyncPriorityQueue(queue);
}
public void PriorityQueue_Dequeue_NonRepeatedValues_Success()
{
// Arrange
var priorityQueue = new PriorityQueue<int>();
var values = new int[] { 10, 7, 6, 1, 2, 3, 5, 4, 9, 8 };
var expected = "1,2,3,4,5,6,7,8,9,10";
// Act
foreach (var value in values)
{
priorityQueue.Enqueue(value);
}
var result = "";
var index = 0;
var lastIndex = priorityQueue.Count() - 1;
while (!priorityQueue.IsEmpty())
{
var element = priorityQueue.Dequeue();
result += index++ == lastIndex ?
string.Format("{0}", element.ToString()) : string.Format("{0},", element.ToString());
}
// Assert
Assert.AreEqual(result, expected);
}
public void RandomTest()
{
PriorityQueue<int> TestObject = new PriorityQueue<int>();
Utilities.Random.Random Rand = new Utilities.Random.Random();
int Value=0;
for (int x = 0; x < 10; ++x)
{
Value=Rand.Next();
TestObject.Add(x, Value);
Assert.Equal(Value, TestObject.Peek());
}
int HighestValue = TestObject.Peek();
for (int x = 9; x >= 0; --x)
{
Value = Rand.Next();
TestObject.Add(x, Value);
Assert.Equal(HighestValue, TestObject.Peek());
}
int Count=0;
foreach(int Priority in TestObject.Keys)
{
foreach(int Item in TestObject[Priority])
{
++Count;
}
}
Assert.Equal(20, Count);
}
public void WithPriority()
{
var priorityQueue = new PriorityQueue<string, int>(PriorityQueueType.Maximum);
priorityQueue.Enqueue("dog", 2);
priorityQueue.Enqueue("canary", 1);
priorityQueue.Enqueue("cat", 3);
int priority;
// Peek gives us "cat"
Assert.AreEqual("cat", priorityQueue.Dequeue(out priority));
// With priority 3
Assert.AreEqual(priority, 3);
// Peek gives us "dog"
Assert.AreEqual("dog", priorityQueue.Dequeue(out priority));
// With priority 2
Assert.AreEqual(priority, 2);
// Peek gives us "canary"
Assert.AreEqual("canary", priorityQueue.Dequeue(out priority));
// With priority 1
Assert.AreEqual(priority, 1);
}
public static void Main()
{
PriorityQueue<int> priorityQueue = new PriorityQueue<int>(true);
priorityQueue.Enqueue(100);
priorityQueue.Enqueue(19);
priorityQueue.Enqueue(36);
priorityQueue.Enqueue(17);
priorityQueue.Enqueue(3);
priorityQueue.Enqueue(25);
priorityQueue.Enqueue(1);
priorityQueue.Enqueue(27);
priorityQueue.Enqueue(22);
priorityQueue.Enqueue(100);
priorityQueue.Enqueue(111);
priorityQueue.Enqueue(222);
priorityQueue.Enqueue(100);
priorityQueue.Enqueue(100);
priorityQueue.Enqueue(324100);
priorityQueue.Enqueue(32);
priorityQueue.Enqueue(4);
while (priorityQueue.Count > 0)
{
Console.WriteLine(priorityQueue.Dequeue());
}
}
// 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 void PriorityQueueGeneralTest()
{
var queue = new PriorityQueue<int>();
Assert.IsTrue(queue.Empty, "New queue should start out empty.");
Assert.Throws<InvalidOperationException>(() => queue.Peek(), "Peeking at an empty queue should throw.");
Assert.Throws<InvalidOperationException>(() => queue.Pop(), "Popping an empty queue should throw.");
foreach (var value in new[] { 4, 3, 5, 1, 2 })
{
queue.Add(value);
Assert.IsFalse(queue.Empty, "Queue should not be empty - items have been added.");
}
foreach (var value in new[] { 1, 2, 3, 4, 5 })
{
Assert.AreEqual(value, queue.Peek(), "Peek returned the wrong item - should be in order.");
Assert.IsFalse(queue.Empty, "Queue should not be empty yet.");
Assert.AreEqual(value, queue.Pop(), "Pop returned the wrong item - should be in order.");
}
Assert.IsTrue(queue.Empty, "Queue should now be empty.");
Assert.Throws<InvalidOperationException>(() => queue.Peek(), "Peeking at an empty queue should throw.");
Assert.Throws<InvalidOperationException>(() => queue.Pop(), "Popping an empty queue should throw.");
}
static void Method(string[] args)
{
int[] hwk = ReadInts();
int h = hwk[0];
int w = hwk[1];
int k = hwk[2];
bool[,] map = new bool[h, w];
int sX = 0, sY = 0;
for (int i = 0; i < h; i++)
{
string s = Read();
for (int j = 0; j < w; j++)
{
if (s[j] == '#')
{
continue;
}
if (s[j] == 'S')
{
sX = j;
sY = i;
}
map[i, j] = true;
}
}
long[,] distances = new long[h, w];
for (int i = 0; i < h; i++)
{
for (int j = 0; j < w; j++)
{
distances[i, j] = long.MaxValue / 4;
}
}
int[] dx = new int[4] {
1, -1, 0, 0
};
int[] dy = new int[4] {
0, 0, 1, -1
};
PriorityQueue <int[]> queue = new PriorityQueue <int[]>();
queue.Enqueue(0, new int[2] {
sX, sY
});
while (queue.Count > 0)
{
var pair = queue.Dequeue();
long distance = pair.Key;
int x = pair.Value[0];
int y = pair.Value[1];
if (distance >= distances[y, x])
{
continue;
}
distances[y, x] = distance;
for (int i = 0; i < 4; i++)
{
int nx = x + dx[i];
int ny = y + dy[i];
if (nx < 0 || w <= nx || ny < 0 || h <= ny)
{
continue;
}
long newDistance = distance + 1;
if (!map[ny, nx] && distance <= k)
{
newDistance = k + 1;
}
if (newDistance >= distances[ny, nx])
{
continue;
}
queue.Enqueue(newDistance, new int[2] {
nx, ny
});
}
}
long res = long.MaxValue;
for (int i = 0; i < h; i++)
{
for (int j = 0; j < w; j++)
{
if (i == 0 || i == h - 1 || j == 0 || j == w - 1)
{
long tmp = distances[i, j] / k;
if (distances[i, j] % k > 0)
{
tmp++;
}
res = Min(res, tmp);
}
}
}
WriteLine(res);
}
public ChunkAwarePacketReceiver(LoadedChunks loadedChunks)
{
this.deferredPacketsByChunk = new Dictionary <Int3, Queue <Packet> >();
this.receivedPackets = new PriorityQueue <Packet>();
this.loadedChunks = loadedChunks;
}
/// <summary>Run the Evalb scoring metric on guess/gold input.</summary>
/// <remarks>Run the Evalb scoring metric on guess/gold input. The default language is English.</remarks>
/// <param name="args"/>
public static void Main(string[] args)
{
if (args.Length < minArgs)
{
log.Info(Usage());
System.Environment.Exit(-1);
}
Properties options = StringUtils.ArgsToProperties(args, OptionArgDefs());
Language language = PropertiesUtils.Get(options, "l", Language.English, typeof(Language));
ITreebankLangParserParams tlpp = language.@params;
int maxGoldYield = PropertiesUtils.GetInt(options, "y", int.MaxValue);
bool Verbose = PropertiesUtils.GetBool(options, "v", false);
bool sortByF1 = PropertiesUtils.HasProperty(options, "s");
int worstKTreesToEmit = PropertiesUtils.GetInt(options, "s", 0);
PriorityQueue <Triple <double, Tree, Tree> > queue = sortByF1 ? new PriorityQueue <Triple <double, Tree, Tree> >(2000, new Evalb.F1Comparator()) : null;
bool doCatLevel = PropertiesUtils.GetBool(options, "c", false);
string labelRegex = options.GetProperty("f", null);
string encoding = options.GetProperty("e", "UTF-8");
string[] parsedArgs = options.GetProperty(string.Empty, string.Empty).Split("\\s+");
if (parsedArgs.Length != minArgs)
{
log.Info(Usage());
System.Environment.Exit(-1);
}
string goldFile = parsedArgs[0];
string guessFile = parsedArgs[1];
// Command-line has been parsed. Configure the metric for evaluation.
tlpp.SetInputEncoding(encoding);
PrintWriter pwOut = tlpp.Pw();
Treebank guessTreebank = tlpp.DiskTreebank();
guessTreebank.LoadPath(guessFile);
pwOut.Println("GUESS TREEBANK:");
pwOut.Println(guessTreebank.TextualSummary());
Treebank goldTreebank = tlpp.DiskTreebank();
goldTreebank.LoadPath(goldFile);
pwOut.Println("GOLD TREEBANK:");
pwOut.Println(goldTreebank.TextualSummary());
Evalb metric = new Evalb("Evalb LP/LR", true);
EvalbByCat evalbCat = (doCatLevel) ? new EvalbByCat("EvalbByCat LP/LR", true, labelRegex) : null;
ITreeTransformer tc = tlpp.Collinizer();
//The evalb ref implementation assigns status for each tree pair as follows:
//
// 0 - Ok (yields match)
// 1 - length mismatch
// 2 - null parse e.g. (()).
//
//In the cases of 1,2, evalb does not include the tree pair in the LP/LR computation.
IEnumerator <Tree> goldItr = goldTreebank.GetEnumerator();
IEnumerator <Tree> guessItr = guessTreebank.GetEnumerator();
int goldLineId = 0;
int guessLineId = 0;
int skippedGuessTrees = 0;
while (guessItr.MoveNext() && goldItr.MoveNext())
{
Tree guessTree = guessItr.Current;
IList <ILabel> guessYield = guessTree.Yield();
guessLineId++;
Tree goldTree = goldItr.Current;
IList <ILabel> goldYield = goldTree.Yield();
goldLineId++;
// Check that we should evaluate this tree
if (goldYield.Count > maxGoldYield)
{
skippedGuessTrees++;
continue;
}
// Only trees with equal yields can be evaluated
if (goldYield.Count != guessYield.Count)
{
pwOut.Printf("Yield mismatch gold: %d tokens vs. guess: %d tokens (lines: gold %d guess %d)%n", goldYield.Count, guessYield.Count, goldLineId, guessLineId);
skippedGuessTrees++;
continue;
}
Tree evalGuess = tc.TransformTree(guessTree);
Tree evalGold = tc.TransformTree(goldTree);
metric.Evaluate(evalGuess, evalGold, ((Verbose) ? pwOut : null));
if (doCatLevel)
{
evalbCat.Evaluate(evalGuess, evalGold, ((Verbose) ? pwOut : null));
}
if (sortByF1)
{
StoreTrees(queue, guessTree, goldTree, metric.GetLastF1());
}
}
if (guessItr.MoveNext() || goldItr.MoveNext())
{
System.Console.Error.Printf("Guess/gold files do not have equal lengths (guess: %d gold: %d)%n.", guessLineId, goldLineId);
}
pwOut.Println("================================================================================");
if (skippedGuessTrees != 0)
{
pwOut.Printf("%s %d guess trees\n", "Unable to evaluate", skippedGuessTrees);
}
metric.Display(true, pwOut);
pwOut.Println();
if (doCatLevel)
{
evalbCat.Display(true, pwOut);
pwOut.Println();
}
if (sortByF1)
{
EmitSortedTrees(queue, worstKTreesToEmit, guessFile);
}
pwOut.Close();
}
public SplPriorityQueue()
{
_queue = new PriorityQueue <Pair>(this);
}
public static List <int> DijkstraAlgorithm(Dictionary <Node, Dictionary <Node, int> > graph, Node sourceNode, Node destinationNode)
{
int?[] previous = new int?[graph.Count];
bool[] visited = new bool[graph.Count];
PriorityQueue <Node> priorityQueue = new PriorityQueue <Node>();
foreach (var pair in graph)
{
pair.Key.DistanceFromStart = double.PositiveInfinity;
}
sourceNode.DistanceFromStart = 0;
priorityQueue.Enqueue(sourceNode);
while (priorityQueue.Count > 0)
{
var currentNode = priorityQueue.ExtractMin();
if (currentNode == destinationNode)
{
break;
}
foreach (var edge in graph[currentNode])
{
if (!visited[edge.Key.Id])
{
priorityQueue.Enqueue(edge.Key);
visited[edge.Key.Id] = true;
}
double distance = currentNode.DistanceFromStart + edge.Value;
if (distance < edge.Key.DistanceFromStart)
{
edge.Key.DistanceFromStart = distance;
previous[edge.Key.Id] = currentNode.Id;
priorityQueue.DecreaseKey(edge.Key);
}
}
}
if (double.IsInfinity(destinationNode.DistanceFromStart))
{
return(null);
}
List <int> path = new List <int>();
int? current = destinationNode.Id;
while (current != null)
{
path.Add(current.Value);
current = previous[current.Value];
}
path.Reverse();
return(path);
}
static void Method(string[] args)
{
int[] nk = ReadInts();
int n = nk[0];
int k = nk[1];
int[] ps = ReadInts();
HashSet <long> hashSet = new HashSet <long>();
PriorityQueue <bool> ascQueue = new PriorityQueue <bool>();
PriorityQueue <bool> descQueue = new PriorityQueue <bool>();
int incCnt = 0;
for (int i = 0; i < k; i++)
{
hashSet.Add(ps[i]);
ascQueue.Enqueue(ps[i], true);
descQueue.Enqueue(-ps[i], true);
if (i > 0 && ps[i] > ps[i - 1])
{
incCnt++;
}
else
{
incCnt = 0;
}
}
bool ordered = incCnt == k - 1;
int res = 1;
for (int i = 1; i + k <= n; i++)
{
if (ps[i + k - 1] > ps[i + k - 2])
{
incCnt++;
}
else
{
incCnt = 0;
}
if (ascQueue.Top().Key == ps[i - 1] &&
-descQueue.Top().Key < ps[i + k - 1])
{
}
else if (ordered && incCnt == k - 1)
{
}
else
{
res++;
}
hashSet.Remove(ps[i - 1]);
hashSet.Add(ps[i + k - 1]);
ascQueue.Enqueue(ps[i + k - 1], true);
descQueue.Enqueue(-ps[i + k - 1], true);
while (!hashSet.Contains(ascQueue.Top().Key))
{
ascQueue.Dequeue();
}
while (!hashSet.Contains(-descQueue.Top().Key))
{
descQueue.Dequeue();
}
if (incCnt == k - 1)
{
ordered = true;
}
}
WriteLine(res);
}
public void Fitting(Func <CompressedTimeSpan, float> originalCurve, CompressedTimeSpan stepSize, float maxErrorThreshold)
{
// Some info: http://wscg.zcu.cz/wscg2008/Papers_2008/full/A23-full.pdf
// Compression of Temporal Video Data by Catmull-Rom Spline and Quadratic Bézier Curve Fitting
// And: http://bitsquid.blogspot.jp/2009/11/bitsquid-low-level-animation-system.html
// Only one or zero keys: no need to do anything.
if (KeyFrames.Count <= 1)
{
return;
}
var keyFrames = new LinkedList <KeyFrameData <float> >(this.KeyFrames);
var evaluator = new Evaluator(keyFrames);
// Compute initial errors (using Least Square Equation)
var errors = new LinkedList <ErrorNode>();
//var errors = new List<float>();
var errorQueue = new PriorityQueue <LinkedListNode <ErrorNode> >(new ErrorComparer());
foreach (var keyFrame in keyFrames.EnumerateNodes())
{
if (keyFrame.Next == null)
{
break;
}
var error = EvaluateError(originalCurve, evaluator, stepSize, keyFrame.Value, keyFrame.Next.Value);
var errorNode = errors.AddLast(new ErrorNode(keyFrame, error.Key, error.Value));
errorQueue.Enqueue(errorNode);
}
//for (int keyFrame = 0; keyFrame < KeyFrames.Count - 1; ++keyFrame)
//{
// //errors.Add(EvaluateError(originalCurve, evaluator, stepSize, keyFrame));
// var errorNode = errors.AddLast(new ErrorNode(EvaluateError(originalCurve, evaluator, stepSize, keyFrame)));
// errorQueue.Enqueue(errorNode);
//}
while (true)
{
// Already reached enough subdivisions
var highestError = errorQueue.Dequeue();
if (highestError.Value.Error <= maxErrorThreshold)
{
break;
}
//// Find segment to optimize
//var biggestErrorIndex = 0;
//for (int keyFrame = 1; keyFrame < KeyFrames.Count - 1; ++keyFrame)
//{
// if (errors[keyFrame] > errors[biggestErrorIndex])
// biggestErrorIndex = keyFrame;
//}
//// Already reached enough subdivisions
//if (errors[biggestErrorIndex] <= maxErrorThreshold)
// break;
// Create new key (use middle point, but better heuristic might improve situation -- like point with biggest error)
//var middleTime = (start.Value.Time + end.Value.Time) / 2;
var middleTime = highestError.Value.BiggestDeltaTime;
//KeyFrames.Insert(biggestErrorIndex + 1, new KeyFrameData<float> { Time = middleTime, Value = originalCurve(middleTime) });
var newKeyFrame = keyFrames.AddAfter(highestError.Value.KeyFrame, new KeyFrameData <float> {
Time = middleTime, Value = originalCurve(middleTime)
});
//errors.Insert(biggestErrorIndex + 1, 0.0f);
var newError = errors.AddAfter(highestError, new ErrorNode(newKeyFrame, CompressedTimeSpan.Zero, 0.0f));
var highestErrorLastUpdate = newError;
if (highestErrorLastUpdate.Next != null)
{
highestErrorLastUpdate = highestErrorLastUpdate.Next;
}
// Invalidate evaluator (data changed)
evaluator.InvalidateTime();
// Update errors
for (var error = highestError.Previous ?? highestError; error != null; error = error.Next)
{
if (error != highestError && error != newError)
{
errorQueue.Remove(error);
}
var errorInfo = EvaluateError(originalCurve, evaluator, stepSize, error.Value.KeyFrame.Value, error.Value.KeyFrame.Next.Value);
error.Value.BiggestDeltaTime = errorInfo.Key;
error.Value.Error = errorInfo.Value;
errorQueue.Enqueue(error);
if (error == highestErrorLastUpdate)
{
break;
}
}
}
KeyFrames = new List <KeyFrameData <float> >(keyFrames);
}