Software Engineer Explore Uncomplicated Game Algorithms Amongst Coloring Walk: Business Office 9

Welcome dorsum for to a greater extent than exploration of game algorithms using the elementary game depth-first search (DFS), the counterpart to the previously discussed breadth-first search (BFS). These graph algorithms do a total search of the graph of a color walk game, the total laid of board positions resulting from each motility at each betoken inwards the game. We constitute that running either of these algorithms to completion is extremely prohibitive due to the graph size beingness exponential inwards the number of moves. In club to bargain with that exponential growth, nosotros demand to await at other graph algorithms, in addition to nosotros receive got quite a few to direct from. We'll explore some categories of graph algorithms in addition to await at ane inwards to a greater extent than detail, Dijkstra's algorithm.

Different Graph Algorithms for Different Questions

Before getting into the algorithms, nosotros should review what makes upward a graph in addition to how it relates to the motility graph for Color Walk. Most graph algorithms, beyond the basic BFS in addition to DFS, are designed to piece of work on graphs with weighted edges. Influenza A virus subtype H5N1 weight on an border agency the border has a value associated with it that tin live thought of every bit a damage of traversing that border from ane vertex to another. Influenza A virus subtype H5N1 vertex is the same thing every bit what we've been calling, thence far, a node, because we've been talking almost the game's motility graphs every bit trees. Internal nodes inwards a tree are connected yesteryear edges in addition to terminate inwards leafage nodes. The root node of the motility tree is just some other vertex, in addition to inwards the instance of a generic graph, whatsoever vertex inwards the graph could potentially live the root node of a corresponding tree. We just receive got to pick which vertex nosotros desire to utilization every bit the root, in addition to the ease of the tree branches out from there. In the instance of our motility graph, nosotros pick the vertex with the starting board seat every bit the root of the tree.

We tin farther compare trees in addition to graphs yesteryear noticing that a tree is a special type of graph, namely a directed, acyclic graph (DAG). Directed agency that edges are traversed inwards ane direction, in addition to inwards the motility graph that management is from vertices corresponding to before moves to vertices corresponding to afterwards moves. More precisely, the vertices are the board positions that are arrived at for each move, in addition to the edges stand upward for the moves that alter ane board seat into some other board seat yesteryear removing blocks.

Acyclic agency that a vertex cannot live revisited yesteryear next some finite number of edges without backtracking (since the DAG has directed edges, nosotros can't backtrack anyway). The motility graph isn't quite acyclic because each vertex has an border to itself for the same motility every bit the motility that results inwards that board position. Some vertexes also receive got edges that come upward dorsum to themselves because the corresponding motility doesn't withdraw whatsoever blocks, resulting inwards the same board position. These cycles tin easily live detected in addition to eliminated, every bit nosotros saw inwards the BFS in addition to DFS algorithms, thence the motility tree tin live thought of every bit a DAG, fifty-fifty if it isn't inwards the strictest sense, yesteryear removing these cyclic edges.

Returning to the thought of border weights, most graph algorithms piece of work yesteryear optimizing the damage of traversing edges yesteryear their weights. Influenza A virus subtype H5N1 path consisting of the lowest total of weights is considered the best path, in addition to graph algorithms volition piece of work to divulge those paths. We receive got already been assigning weights to the edges inwards our greedy algorithms. We called them heuristics instead of weights, but they amount to the same thing. The heuristic values associated with each motility tin live considered the weights assigned to each corresponding border inwards the graph. Different heuristics are unlike weight functions. For example, inwards the basic greedy algorithm the heuristic was the number of blocks removed on a given move. The number of blocks removed would live the weight of the border corresponding to that move. So far all of the weights we've used receive got been positive, but it is viable to receive got negative weights on graph edges every bit well. Some graph algorithms volition piece of work with negative weights, acre others require all positive (or all negative) weights.

Graph algorithms tin live classified into 4 unlike types, based on what they solve for a given graph. Minimum spanning tree algorithms volition divulge the minimum laid of edges, taking weights into account, that connects all of the nodes inwards the graph. Basically, these algorithms withdraw the most costly in addition to unnecessary edges from the graph to create a tree nevertheless containing all vertices from the master copy graph. Since our motility graph is already a tree in addition to we're interested inwards finding the minimum path from ane vertex to another, minimum spanning tree algorithms won't live every bit good useful for us, but they do solve a large aeroplane of problems, including automatic routers for circuit board or integrated circuit layouts, for example.

The shortest paths algorithms are the ones we're most interested in. These algorithms divulge the lowest-cost path from a source vertex to all other vertices inwards the graph. It is interesting that solving this employment is asymptotically every bit fast every bit finding the shortest path betwixt 2 specific nodes, but nosotros are working with an enormous graph, thence we'll receive got to brand some modifications to Dijkstra's algorithm, the shortest path algorithm we'll use, to brand it tractable for the motility graphs. Part of that modification volition live stopping early on when nosotros divulge the shortest path to the terminate vertex we're looking for.

Another type of algorithm that's similar to the shortest paths algorithms is the all-pairs shortest paths algorithm. These algorithms volition efficiently divulge the shortest paths betwixt all pairs of vertices inwards a graph. This employment seems much larger than the single-source shortest path problem, but it tin truly live solved faster than iterating through every vertex in addition to running Dijkstra's algorithm. We don't demand to do this for our problem, thence nosotros won't live looking into this type of algorithm here.

The lastly type is the maximum flow algorithms. These algorithms receive got a couplet of vertices in addition to divulge the maximum charge per unit of measurement that something tin motility through the graph from ane vertex to the other without inundation whatsoever of the weights inwards the graph. The weights tin live thought of every bit capacities for each border betwixt vertices, in addition to this type of employment has all kinds of applications such every bit electricity inwards wires, liquids inwards pipes, traffic flow, assembly lines, in addition to much more. Yet, it's non useful for our immediate problem, although it's practiced to know that these algorithms exist.

Single-Source Shortest Path Algorithms

As described just a instant ago, single-source shortest path algorithms volition divulge the shortest path from a source vertex to all other vertices inwards the graph. Let's ignore for the instant that this is a colossal employment for our motility graphs, with good over 4⁴⁰ vertices for most boards fifty-fifty after trimming out all cyclical edges. Instead, think almost what the graph looks like. It's a tree with a unmarried root node, our source vertex, that spreads out at each aeroplane yesteryear a factor of four.

At some betoken the branches inwards the exponentially expanding tree volition start reaching leafage nodes, but these leafage nodes are, inwards fact, all the same vertex—an empty board. That agency at some betoken every branching path inwards the tree volition terminate upward at the same vertex with an enormous number of edges coming into it, in addition to nosotros desire to divulge the ane that comes from the path through the to the lowest degree number of vertices. This is a potentially simplifying insight that we'll receive got to hold inwards mind. Take the representative sub-graph pictured below every bit an example, where at that topographic point are iii colors to direct from for moves, in addition to each vertex is labeled with its motility number. Eventually, every path of moves ends inwards the same place, at the terminate vertex.

The most straightforward way to divulge this path is to utilization the Bellman-Ford algorithm. This algorithm volition sweep through every vertex inwards the graph, in addition to for each vertex it volition receive got each border inwards the graph in addition to relax it. You see, each border has a source vertex, where the border comes from, in addition to a sink vertex, where the border goes to. Each vertex volition also receive got a distance associated with it that starts at infinity, unless it is the overall source vertex where the path starts, inwards which instance the distance is zero. Relaxing an border agency that nosotros compare the distance of the sink vertex with the distance of the source vertex plus the border weight. If the sink distance is more, in addition to then the sink distance volition live updated to the source distance plus the border weight. The pseudo-JavaScript code for the Bellman-Ford algorithm looks similar this:

function BellmanFord(graph) {   _.each(graph.vertices, function(vertex) {     _.each(graph.edges, function(edge) {       relax(edge);     });   }); }  business office relax(edge) {   if (edge.sink.distance > edge.source.distance + edge.weight) {     edge.sink.distance = edge.source.distance + edge.weight;     edge.sink.previous = edge.source;   } }

This code makes some assumptions almost the graph's information structure, namely that it has a listing of vertices in addition to edges, in addition to each border has properties for its source in addition to sink vertices in addition to weight. Vertices receive got properties for their distance in addition to a link to the previous vertex that is on the currently constitute shortest path. Influenza A virus subtype H5N1 proof of the correctness of this algorithm is a fleck every bit good involved to larn into here, but essentially, it relaxes every border inwards the graph for every vertex inwards the graph thence that the calculated distances are guaranteed to fully propagate through the graph. The termination is that each vertex volition receive got its shortest distance to the source vertex, in addition to a link to the previous vertex inwards its shortest path.

This algorithm is dead simple, but also completely unworkable for our employment for 2 reasons. First, it requires us to generate in addition to shop the entire motility graph before running the algorithm. This business has already been shown to live quite beyond the mightiness of whatsoever reckoner for the foreseeable future. Second, nosotros receive got to run relax(edge) for every border inwards the graph, in addition to do that total sweep of edges for every vertex inwards the graph. In other words, this algorithm is O(V²) where V is the number of vertices. Such a processing feat is never going to happen. We demand to divulge a improve way.

One thing nosotros should notice is that the Bellman-Ford algorithm is doing a ton of extra piece of work to propagate distances through the graph. Most vertex distances volition non alter on whatsoever exceptional sweep of the edges because the distances to a greater extent than or less them haven't changed. The algorithm was designed to piece of work with whatsoever type of graph in addition to tolerate cycles, but the motility graph has the added restriction of beingness a DAG. Using that restriction, nosotros tin improve the algorithm yesteryear traversing the graph inwards breadth-first club acre relaxing edges.

function dagShortestPaths(graph) {   var vertices = novel Queue();   vertices.enqueue(graph.root);   acre (vertices.getLength() > 0) {     var vertex = vertices.dequeue();     _.each(vertex.edges, function(edge) {       relax(edge);       vertices.enqueue(edge.sink);     });   } }

The relax() business office is the same every bit with Bellman-Ford. With this improvement, we're doing much less work, acre propagating vertex distances inwards a way that ensures that vertices are updated chop-chop in addition to without a lot of extra waste. In the instance of our motility graph, where vertices nearly ever receive got ane incoming edge, the running fourth dimension volition live O(V).

This algorithm is a keen improvement over Bellman-Ford, but we've come across a somewhat featherbrained issue. This algorithm is basically BFS with border weights added into the mix. Because border weights are just an additional metric inwards the motility graph in addition to non a strict damage of traversing the edges, they decease meaningless, in addition to the algorithm volition perform no improve than BFS. It should live obvious that it would receive got at to the lowest degree every bit long to run, in addition to if nosotros allow it to run over the entire graph every bit defined, much longer. Remember, BFS stopped every bit presently every bit it constitute the empty board node.

This DAG shortest paths algorithm is keen for smaller DAGs than what we're working with, in addition to with DAGs that receive got truthful border weights instead of weights that we're just using every bit heuristics. What nosotros demand is an algorithm that uses the border weights inwards a way that dramatically reduces the number of vertices visited before the destination node is visited, in addition to for that nosotros demand Dijkstra's algorithm.

Dijkstra's Algorithm

To implement Dijkstra's algorithm for the Color Walk motility graph, we're going to demand to revisit the the heuristics nosotros would utilization for border weights. Simply using the number of blocks removed for each border (move) belike won't live practiced enough, but to see why, let's outset await at an outline of the algorithm.

function Dijkstra(graph)   var vertices = novel Queue();   vertices.enqueue(graph.root);   while(vertices.getLength() > 0) {     var vertex = vertices.extractMin();     _.each(vertex.edges, function(edge) {       relax(edge);       vertices.enqueue(edge.sink);     });   } }

Waaait a minute! This algorithm looks almost exactly similar the DAG shortest paths algorithm, which looks almost exactly similar BFS. What gives? In truth, it is very similar to both of those algorithms. The telephone commutation difference hither is that we're non pulling the vertices out of the queue inwards the same club that we're adding them in. We're pulling out the vertex with the minimum distance to the source vertex of all the vertices inwards the queue with vertices.extractMin(). That agency the queue is truly a priority queue of some kind. That agency that we're efficiently prioritizing which path we're looking at each fourth dimension nosotros await at a novel vertex. That agency nosotros demand to brand certainly we're prioritizing the vertices with the right weight function.

When nosotros were searching for the empty board node with BFS, nosotros were searching inwards motility order, important nosotros searched all outset moves before searching all 2nd moves, before searching all tertiary moves, in addition to thence on. Now with Dijkstra's algorithm, nosotros could live searching moves out-of-order. We could live headed downwards a promising path on the 12th motility when the side yesteryear side vertex pulled out of the priority queue is truly for the 10th motility because the previous 12-move path has gotten every bit good long, in addition to at that topographic point are shorter paths with less moves at the top of the queue. We desire to capture the belongings that the shortest path is the ane with the to the lowest degree number of moves, but residual that with the thought that moves that withdraw to a greater extent than blocks are probable to live on the shortest path.

The employment with just combining the motility number for a vertex in addition to the number of blocks removed for that vertex is that nosotros desire to minimize the old in addition to maximize the latter. We can't mix the 2 goals. We demand to pick either minimization or maximization for the priority queue to work. It doesn't much affair which way nosotros choose, thence we'll stick with minimization in addition to brand the values for number of blocks removed negative. Thus, the weight for whatsoever given border is

weight = 1 - blocks_removed_on_move

This equation is truthful because each motility volition increment the number of moves yesteryear 1 in addition to withdraw a certainly number of blocks. To calculate the distance associated with a novel vertex, v, nosotros add together the weight to the distance of the previous vertex, u:

distance_v = distance_u + weight_u,v

We tin simplify this equation yesteryear noticing that the distance to whatsoever vertex is just the accumulation of moves minus the accumulation of blocks removed, or:

distance_v = move_number - blocks_removed

With that worked out, nosotros tin start implementing our version of Dijkstra's algorithm for Color Walk. First, nosotros add together the algorithm to the listing of choices inwards the HTML input chemical component in addition to to the switch statement:

  business office Solver() {     // ...      this.init = function() {       // ...        $('#solver_type').change(function () {         switch (this.value) {           // ...           instance 'dijkstra':             that.solverType = that.dijkstra;             that.metric = areaCount;             break;           default:             that.solverType = that.roundRobin;             break;         }          // ...       });        // ...     };

Then nosotros demand to fill upward inwards the algorithm function, which is similar to the BFS algorithm, but with a priority queue instead of a regular queue in addition to some changes to the bound checking on the size of the queue:

    this.dijkstra = function() {       var vertices = novel PriorityQueue({ comparator: function(a, b) { render a.cost - b.cost } });       vertices = addVertices(vertices, 1, null, blocks[0].cluster.blocks.length);        acre (vertices.length > 0) {         var vertex = vertices.dequeue();         markers = vertex.markers;          if (vertices.length > 250000) {           doMarkedMoves();           vertices.clear();         } else {           vertices = addVertices(vertices, vertex.depth + 1, vertex.control, vertex.cleared);         }          vertex.markers = null;       }     }

This code follows the outline of the pseudocode presented to a higher house fairly closely. It creates a priority queue, adds the outset vertex, in addition to and then loops through vertices, pulling the vertex with the minimum damage (or distance, they're interchangeable) out of the queue each fourth dimension in addition to adding its tyke vertices to the queue within addVertices(). I looked to a greater extent than or less for a JavaScript priority queue to utilization for this task, in addition to constitute a overnice ane with a build clean API. When creating the queue, you lot demand to furnish a comparator business office thence that it knows how to compare the value of nodes inwards the queue in addition to maintain its priority requirement. The damage properties are an additional belongings on the vertices that's calculated within addVertices().

Because the vertices don't remain inwards inserted order, in addition to nosotros demand to know the damage of vertices before adding them to the queue, nosotros demand to run checkGameBoard() on each vertex inwards addVertices(). (Check out this previous post service on BFS for details on how it was implemented before.) This alter simplifies the to a higher house business office a bit, in addition to other than what's already been described, nosotros alone demand to brand certainly the queue doesn't larn every bit good big. If it reaches every bit good large of a size, we're going to forget adding to a greater extent than vertices, do the moves corresponding to the electrical current minimum vertex, clear the queue, in addition to bail out. We'll come upward to a greater extent than or less in ane lawsuit again at the novel motility number in addition to partially cleared board to travail in ane lawsuit again to divulge the end-of-game vertex. Some boards volition receive got thence many similarly weighted paths that this tactic is necessary, otherwise the queue volition larn every bit good large in addition to drive a crash. Surprisingly, this doesn't hap every bit good often, in addition to the algorithm volition live able to consummate the search on most boards inwards a unmarried sweep.

Now let's await at what's going on inwards addVertices(). The thought is simple. This business office needs to run through all of the controls, checking to see how many blocks each command removes, calculating the damage of each of these novel vertices, in addition to adding the vertices to the queue. If it runs into the end-of-game vertex, it should stop. Here's what it looks like:

    business office addVertices(vertices, depth, prev_control, prev_cleared) {       var halt = false;       _.each(controls, business office (control) {         if (control !== prev_control && !stop) {           var removed_blocks = control.checkGameBoard(depth, areaCount);            if (endOfGame()) {             doMarkedMoves();             vertices.clear();             halt = true;           } else if (removed_blocks - prev_cleared > 0) {             var markers_dup = markers.slice();             var damage = max_moves*depth - removed_blocks;             if (removed_blocks > 590) damage -= (max_moves - 5)*depth;             vertices.queue({markers: markers_dup,                              depth: depth,                              control: control,                              cost: cost,                              cleared: removed_blocks});           }         }       });

While the concept of the business office is simple, the implementation has a number of tricky details. I had a pretty crude oil fourth dimension getting this code right. It tripped me upward to a greater extent than times than I aid to admit, but let's decease through in addition to await at each exceptional anyway. Starting at the top, nosotros demand a halt flag to know when we've constitute the end-of-game in addition to demand to halt searching. If nosotros alone did the moves in addition to cleared out the queue, nosotros may receive got constitute the terminate acre having to a greater extent than controls to loop through, in addition to the each() business office would continue its merry way, adding to a greater extent than vertices to the late emptied queue. The algorithm wouldn't truly halt when it was supposed to, thence nosotros demand the flag to brand certainly nosotros ignore whatsoever leftover controls after finding the end-of-game vertex.

Next, the cheque to brand certainly at to the lowest degree ane block was removed on the electrical current motility before adding the novel vertex to the queue needed to live correct. The right calculation is the difference betwixt the removed blocks after the motility in addition to those blocks that were cleared before that move, because areaCount() counts all of the marked blocks inwards markers, non just the ones marked on the electrical current move. Therefore, I needed to overstep prev_cleared, the number of previously cleared blocks, into addVertices() from the rear vertex, which agency I needed to shop the number of blocks removed on a motility inwards that move's vertex for this whole calculation to work.

Another subtle betoken is that with vertices beingness pulled out of the queue inwards a unlike club than they were inserted, each laid of markers needed to live copied instead of sharing the same re-create alongside all of the tyke vertices from whatsoever given rear vertex. That agency the markers.slice() line needed to larn moved within the each() loop.

Then, the basic damage business office of move_number - blocks_removed didn't piece of work every bit good well. Why that is has to do with the scale of those 2 values in addition to how they piece of work together. Imagine getting rid of either ane of them. If the damage business office was alone move_number, in addition to then every vertex with a smaller motility number would live pulled out of the priority queue before whatsoever vertex with a larger motility number. Dijkstra's algorithm would trim back to BFS inwards that case. If, on the other hand, the damage business office was alone -blocks_removed, in addition to then the vertex with the most blocks removed would ever live pulled out of the queue first, reducing the algorithm to the greedy algorithm.

These iii possible damage functions all prevarication on a continuum, with BFS on ane end, the greedy algorithm on the other end, in addition to move_number - blocks_removed somewhere inwards the middle. But move_number - blocks_removed is non the alone intermediate option. Consider that move_number is on the club of 30-40 moves, in addition to blocks_removed will ever terminate inwards 600 for a 30x20 block board. The move_number has much less weight than blocks_removed, but nosotros tin add together a scale factor to it. This scale factor is truly necessary to larn practiced functioning because otherwise it's possible, in addition to indeed likely, that the minimum vertex pulled out of the queue at some betoken during the search volition clear out a dozen or to a greater extent than blocks in addition to terminate the game, but live several moves to a greater extent than than the minimum number of moves. We desire to add together weight to move_number, thence nosotros tin utilization max_moves from the UI input every bit the scale factor for move_number (represented inwards the code every bit depth).

With the right scale factor—found to live to a greater extent than or less 25—the functioning of the algorithm is much better, but it in addition to then hits some other snag. Near the terminate of the search, the algorithm hits a wall in addition to starts churning on all of the other possibilities inwards the queue because the move_number gets larger than blocks_removed on the vertices closest to the end-of-game vertex. The algorithm variety of devolves into BFS again, in addition to it would receive got forever backtracking to explore older paths inwards its history unless nosotros tin divulge a way of forcing it to direct the vertices unopen to the destination line. To strength this behavior, if we're within 10 blocks of finishing, we'll trim back the scale factor to bump the priority of those vertices. Since we're within 10 blocks of finishing, at that topographic point are probable alone a few colors of blocks left, in addition to nosotros tin motility to a greater extent than towards the greedy algorithm on the spectrum to destination quickly.

After getting all of these little, of import details right, nosotros tin finally run a version of Dijkstra's algorithm that volition run to completion without crashing and, hopefully, divulge some practiced solutions to the game boards. Let's see what happens when nosotros run 100 iterations of this algorithm.

Dijkstra's Algorithm Results

We should hold inwards take heed when looking at these results that the version of Dijkstra's algorithm that we're using is non the consummate algorithm. We're intentionally stopping early on when nosotros divulge the outset end-of-game vertex because if nosotros allow it run to completion, it would receive got an eternity to run, in addition to inwards its electrical current shape would ever run out of retentiveness in addition to crash. Taking that into account, hither are the results with a motility scale factor of 25:

That termination seems pretty good. How does it stack upward to the other algorithms?

Algorithm	Min	Mean	Max	Stdev
RR with Skipping	37	46.9	59	4.1
Random with Skipping	43	53.1	64	4.5
Greedy	31	39.8	48	3.5
Greedy Look-Ahead-2	28	37.0	45	3.1
Greedy Look-Ahead-5	25	33.1	41	2.8
Max Perimeter	29	37.4	44	3.2
Max Perimeter Look-Ahead-2	27	35.0	44	2.8
Perimeter-Area Hybrid	31	39.0	49	3.8
Deep-Path	51	74.8	104	9.4
Path-Area Hybrid	35	44.2	54	3.5
Path-Area Hybrid Look-Ahead-4	32	38.7	45	2.7
BFS with Greedy Look-Ahead-5	26	32.7	40	2.8
DFS with Greedy Look-Ahead-5	25	34.8	43	3.9
Dijkstra's Algorithm	29	33.1	40	1.9

Well, the minimum number of moves for Dijkstra's algorithm was bested yesteryear GLA, BFS, in addition to DFS, but the hateful was alone barely bested yesteryear BFS in addition to the maximum was equal to the previous best, BFS. Look at the measure deviation, though. Dijkstra's algorithm gives consistently practiced solutions yesteryear a important margin. The side yesteryear side best algorithm for giving consistent results is the deep path-area hybrid algorithm with look-ahead yesteryear 4, in addition to that ane performs 5.6 moves worse on average.

Dijkstra's algorithm definitely has some overnice characteristics, but why doesn't it perform the best inwards all cases? The primary argue is because of what was mentioned earlier: we're non running the algorithm to completion. Cutting it off early on agency that at that topographic point are nevertheless potentially shorter paths inwards the priority queue that could live explored, but nosotros halt searching the outset fourth dimension nosotros divulge the end-of-game vertex. The weight business office also plays a role hither because we're trying to play a balancing human activity betwixt optimizing the primary goal—the number of moves—and the secondary goal that helps focus the search—the number of blocks removed. If nosotros increased the scale factor to add together to a greater extent than weight to the number of moves, the search volition receive got much longer, in addition to it volition run out of retentiveness for the growing priority queue to a greater extent than often, requiring the algorithm to commit to some number of moves for the lastly minimum vertex it pulls out of the queue in addition to start in ane lawsuit again from that point.

Part of what makes Dijkstra's algorithm thence consistently effective is that it is some other shape of a greedy algorithm, but it keeps rails of other promising paths acre it pursues what looks similar the best choice at every moment. Each fourth dimension through the acre loop, it's looking at the electrical current best possible side yesteryear side vertex inwards the path, in addition to when the tyke vertices of that vertex are added to the queue, the side yesteryear side best vertex may non live ane of those just added, but a vertex from a unlike promising path stored inwards the queue. The algorithm volition recollect all of the other paths it could take, in addition to in ane lawsuit the electrical current path gets every bit good expensive, it volition switch to a cheaper ane until that ane also gets every bit good expensive. This constant evolution of numerous practiced options for the shortest path turns out to live a real efficient way to divulge ane that's quite short, if non the shortest.

Given the potential of Dijkstra's algorithm, we're non quite done exploring it. While implementing it, some options became apparent for making it perform better. We could await at some other hybrid approach with the greedy algorithm, either running the greedy algorithm before or after Dijkstra's algorithm, or nosotros could travail running Dijkstra's algorithm twice—once to one-half the blocks removed in addition to in ane lawsuit again to consummate the game. Much experimentation is possible here, combined with varying the scale factor, to see if nosotros tin force Dijkstra's algorithm to trounce GLA-5. We'll explore those options side yesteryear side time.


Article Index
Part 1: Introduction & Setup
Part 2: Tooling & Round-Robin
Part 3: Random & Skipping
Part 4: The Greedy Algorithm
Part 5: Greedy Look Ahead
Part 6: Heuristics & Hybrids
Part 7: Breadth-First Search
Part 8: Depth-First Search
Part 9: Dijkstra's Algorithm
Part 10: Dijkstra's Hybrids
Part 11: Priority Queues
Part 12: Summary

Share this post