/// <summary> /// based on the pseudocode on wiki page(http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm) /// </summary> static int using_Dijkstra_s_algorithm_with_priority_queue() { var len = 80; var node_map = new Node[len, len]; var queue = new PriorityQueue(len * len); Node source = null; Node goal = null; var row = 0; var col = 0; foreach (var line in File.ReadAllLines("matrix.txt")) { col = 0; foreach (var num in line.Split(new char[] { ',' })) { var node = new Node(Convert.ToInt32(num)) { row = row, col = col }; if (row == 0 && col == 0) source = node; if (row == len - 1 && col == len - 1) goal = node; // node map is mainly used to get neighbors node_map[row, col] = node; queue.Enqueue(node); col++; } row++; } // set the source's distance to zero to kick start the process queue.Update(source, 0); // code for getting neighbor, using closure with the neighbor_list to make life a little easier var neighbor_list = new Node[4]; // 0:left 1:up 2:right 3:down Action<Node> prepare_neighbor_list = n => { neighbor_list[0] = n.col - 1 < 0 ? null : node_map[n.row, n.col - 1]; neighbor_list[1] = n.row - 1 < 0 ? null : node_map[n.row - 1, n.col]; neighbor_list[2] = n.col + 1 >= len ? null : node_map[n.row, n.col + 1]; neighbor_list[3] = n.row + 1 >= len ? null : node_map[n.row + 1, n.col]; }; var total = 0; while (queue.IsEmpty() == false) { var u = queue.DequeueMin(); if (u.distance == int.MaxValue) break; // all remaining vertices are inaccessible from source if (u == goal) { while (u != null) { total += u.cost; u = u.previous; } break; } // call this method before using neighbor_list array prepare_neighbor_list(u); foreach (var v in neighbor_list) { if (v == null) continue; // like when u is edge cell in the matrix var alt = u.distance + u.cost + v.cost; if (alt < v.distance) { v.previous = u; queue.Update(v, alt); } } } return total; }
static void PriorityQueueTest() { { PriorityQueue<int> queueRemoveMin = new PriorityQueue<int>(); PriorityQueue<int> queueRemoveMax = new PriorityQueue<int>(); List<int> doubleCheckMin = new List<int>(); List<int> doubleCheckMax = new List<int>(); Random r = new Random(); // Generate the list of numbers to populate the queue and to check against for (int i = 0; i < 20; i++) { int randInt = r.Next(-100, 100); doubleCheckMin.Add(randInt); } for (int i = 0; i < doubleCheckMin.Count; i++) { int randInt = doubleCheckMin[i]; // heap.Add("" + i, i); queueRemoveMin.Enqueue(randInt, randInt); queueRemoveMax.Enqueue(randInt, randInt); doubleCheckMax.Add(randInt); } doubleCheckMin.Sort(); // Default. Ascending doubleCheckMax.Sort(delegate (int x, int y) { if (x == y) return 0; if (x > y) return -1; if (x < y) return 1; return 0; }); Console.WriteLine(" -- NOW REMOVE MIN --"); int checkCount = 0; while (queueRemoveMin.Count > 0) { int min = queueRemoveMin.DequeueMin(); if (doubleCheckMin[checkCount] != min) { throw new Exception("WRONG!"); } checkCount++; Console.WriteLine(min); } Console.WriteLine(" -- NOW REMOVE MAX --"); checkCount = 0; while (queueRemoveMax.Count > 0) { int max = queueRemoveMax.DequeueMax(); if (doubleCheckMax[checkCount] != max) { throw new Exception("WRONG!"); } checkCount++; Console.WriteLine(max); } } // Now for some random fun. Randomly decide what operation we're performing. // Sorted list is kept alongside for double-checking validity of heap results. { PriorityQueue<int> queue = new PriorityQueue<int>(); queue.DebugValidation = true; List<int> list = new List<int>(); const int kMaxOperations = 2000; int numOps = 0; Random r = new Random(); for (numOps = 0; numOps < kMaxOperations; numOps++) { int randInt = r.Next(0, 4); switch (randInt) { case 0: case 1: // twice as likely to occur { // Add an item. randInt = r.Next(-1000, 1000); Console.WriteLine("Adding : " + randInt); list.Add(randInt); queue.Enqueue(randInt, randInt); if (list.Count != queue.Count) { throw new Exception("Count mismatch!"); } } break; case 2: { // Dequeue Min list.Sort(); if (list.Count != queue.Count) { throw new Exception("Count mismatch! List= " + list.Count + ", queue = " + queue.Count); } if (list.Count == 0) { // well, can't do much here. early break break; } int listMin = list[0]; list.RemoveAt(0); int queueMin = queue.DequeueMin(); if (listMin != queueMin) { throw new Exception("Min mismatch! List=" + listMin + ", queue=" + queueMin); } Console.WriteLine("DequeueMin : " + queueMin); } break; case 3: { // DequeueMax list.Sort(delegate (int x, int y) { if (x == y) return 0; if (x > y) return -1; if (x < y) return 1; return 0; }); if (list.Count != queue.Count) { throw new Exception("Count mismatch! List= " + list.Count + ", queue = " + queue.Count); } if (list.Count == 0) { // well, can't do much here. early break break; } int listMax = list[0]; list.RemoveAt(0); int queueMax = queue.DequeueMax(); if (listMax != queueMax) { throw new Exception("Max mismatch! List=" + listMax + ", queue=" + queueMax); } Console.WriteLine("DequeueMax : " + queueMax); } break; } } Console.WriteLine("All tests passed!"); } }