for a datastructures & algorithms class in college we have to implement an algorithm presented in a paper. The paper can be found here.
So i fullly implemented the algorithm, with still some errors left (but that’s not really why I’m asking this question, if you want to see how I implemented it thus far, you can find it here)
The real reason why I’m asking a question on Stackoverflow is the second part of the assignment: we have to try to make the algorithm better. I had a few ways in mind, but all of them sound good in theory but they won’t really do good in practice:
- Draw a line between the source and end node, search the node closest to the middle of that line and divide the “path” in 2 recursively. The base case would be a smaller graph were a single Dijkstra would do the computation. This isn’t really an adjustment to the current algorithm but with some thinking it is clear this wouldn’t give an optimal solution.
- Try to give the algorithm some sense of direction by giving a higher priority to edges that point to the end node. This also won’t be optimal..
So now I’m all out of ideas and hoping that someone here could give me a little hint for a possible adjustment. It doesn’t really have to improve the algorithm, I think the first reason why they asked us to do this is so we don’t just implement the algorithm from the paper without knowing what’s behind it.
(If Stackoverflow isn’t the right place to ask this question, my apologies 🙂 )
A short description of the algorithm:
The algorithm tries to select which nodes look promising. By promising I mean that they have a good chance on lying on a shortest path. How promising a node is is represented by it’s ‘reach’. The reach of a vertex on a path is the minimum of it’s distances to the start and to the end. The reach of a vertex in a graph is the maximum of the reaches of the vertex on all shortest paths.
To eventually determine whether a node is added to the priority queue in Dijkstra’s algorithm, a test() function is added. Test returns true (if the reach of a vertex in the graph is larger or equal then the weight of the path from the origin to v at the time v is to be inserted in the priority queue) or (the reach of the vertex in the graph is larger or equal then the euclidean distance from v to the end vertex).
Harm De Weirdt
Your best bet in cases like this is to think like a researcher: Research in general and Computer Science research specifically is about incremental improvement, one person shows that they can compute something faster using Dijkstra’s Algorithm and then later they, or someone else, show that they can compute the same thing a little faster using A*. It’s a series of small steps.
That said, the best place to look for ways to improve an algorithm presented in a paper is in the future directions section. This paper gives you a little bit to work on in that direction, but your gold mine in this case lies in sections 5 and 6. There are multiple places where the authors admit to different possible approaches. Try researching some of these approaches, this should lead you either to a possible improvement in the algorithm or at least an arguable one.
Best of luck!