dijkstra | Fastest golang Dijkstra path finder

What you need to do is use the useImperativeHandle, so you can access the function from outside of your component.

First, call useRef to create a reference and pass it to your GridContainer as prop, we will handle the ref later inside the component using fowardRef. Then, you need to wrap the animateAlgorithm inside a handler function and use it as props in NavBar so you call it when the button is clicked.

App.js

There is an error in enqueue in this line:

Not Depth First, but Breadth-First Search (BFS) is perhaps the most effective method to determine "inner circle" of some person.

If you want to reveal at most six levels of separation for two known persons, you also can try bi-directional BFS

Question about "who has relation" to Ken Thompson is quite philosophical... You need to define conditions yourself - perhaps you can reveal pupils in the same school, students and instructors in the same university, relatives, colleagues, all the UNIX users and C programmists ;), ... perhaps no.

You can do it with a modified Dijkstra's that keeps track of whether a node can be reached by multiple shortest paths.

The simplest way is with a container of bool:

This won't be a full proof, you can read "A Note on Finding Shortest Path Trees" (Aaron Kershenbaum, 1981, https://doi.org/10.1002/net.3230110410) if you want that. An other source you may find interesting is "Properties of Labeling Methods for Determining Shortest Path Trees".

The intuitive reason why this algorithm can go bad is that a node in set M0 is pulled out from it again to be re-examined later if an edge that points to it is found. That already sounds quadratic because there could be |V|-1 edges pointing to it, so every node could potentially be "resurrected" that many times, but it's even worse: that effect is self-amplifying because every time a node is "resurrected" in that way, the edges outgoing from that node can cause more resurrections, and so on. In a full proof, some care must be taken with the edge weights, to ensure that enough of those "resurrections" can actually happen, because they are conditional, so [Kershenbaum 1981] presents a way to build an actual example on which Pape's algorithm requires an exponential number of steps.

By the way, in the same paper the author says:

I have used this algorithm to find routes in very large, very sparse real networks (thousands of nodes and average nodal degree between 2 and 3) with a variety of length functions (generally distance-related) and have found it to outperform all others.

(but since no one uses this algorithm, there are not many available benchmarks, except this one in which Pape's algorithm does not compare so favourably)

In contrast, triggering the exponential behaviour requires a combination of a high degree, a particular order of edges in the adjacency list, and unusual edge weights. Some mitigations are mentioned, for example sorting the adjacency lists by weight before running the running the algorithm.

I could not find any real source on this, and don't expect it to exist, after all you would not have to defend not-using some unusual algorithm that has strange properties to boot. There is the exponential worst case (though on closer inspection it seems unlikely to be triggered by accident, and anyway the Simplex algorithm has an exponential worse case, and it is used a lot), it is relatively unknown, and the only available actual benchmark casts doubt on the claim that the algorithm is "usually efficient" (though I will note they used a degree of 4, which still seems low, but it is definitely higher than the "between 2 and 3" used in the claim that the algorithm is efficient). Also, it should not be expected that Pape's algorithm will perform well on dense graphs in general, even if the exponential behaviour is not triggered.

The problem is that you are giving priority to the edges with the least weight, but you should give priority to paths with the least weight.

So near the end of your code change:

Dijkstra's finds the shortest (or least expensive) path between two given nodes. If you want to visit a larger set of nodes, you are looking at the Travelling Salesman Problem.

In the classic TSP, you must visit all nodes in the graph. I don't know if your subset problem has a name, but you can use Dijkstra to find the shortest path between every pair of cities to be visited, reducing your visit-three-cities-out-of-nine to the simpler visit-three-cities which TSP deals with.

A brute-force solution to TSP is O(n!), which is not too bad for a small number of nodes to be visited. Faster algorithms exist, but they are much more advanced, and they aren't exactly fast (O(n²2ⁿ)). Finding a polynomial-time algorithm would get your name in the history books.

Your solution is almost correct.

You assign the name of the city to the current_city variable whereas the original solution assigns the city object.

Actually This statement is wrong.