CODEWITHSUNDEEP
c++graph-algorithmboost-graph
PeteUK
PeteUK

Reputation: 1112

Shortest path graph algorithm help Boost

I have a rectangular grid shaped DAG where the horizontal edges always point right and the vertical edges always point down. The edges have positive costs associated with them. Because of the rectangular format, the nodes are being referred to using zero-based row/column. Here's an example graph:

Example rectangular DAG

Now, I want to perform a search. The starting vertex will always be in the left column (column with index 0) and in the upper half of the graph. This means I'll pick the start to be either (0,0), (1,0), (2,0), (3,0) or (4,0). The goal vertex is always in the right column (column with index 6) and "corresponds" to the start vertex:

start vertex (0,0) corresponds to goal vertex (5,6)

start vertex (1,0) corresponds to goal vertex (6,6)

start vertex (2,0) corresponds to goal vertex (7,6)

start vertex (3,0) corresponds to goal vertex (8,6)

start vertex (4,0) corresponds to goal vertex (9,6)

I only mention this to demonstrate that the goal vertex will always be reachable. It's possibly not very important to my actual question.

What I want to know is what search algorithm should I use to find the path from start to goal? I am using C++ and have access to the Boost Graph Library.

For those interested, I'm trying to implement Fuchs' suggestions from his Optimal Surface Reconstruction from Planar Contours paper.

I looked at A* but to be honest didn't understand it and wasn't how the heuristic works or even whether I could come up with one!

Because of the rectangular shape and regular edge directions, I figured there might be a well-suited algorithm. I considered Dijkstra

but the paper I mention said there were quicker algorithms (but annoyingly for me doesn't provide an implementation), plus that's

single-source and I think I want single-pair.

Upvotes: 2

Views: 976

Answers (2)

gpicchiarelli
gpicchiarelli

Reputation: 452

So, this is your problem,

  1. DAG no cycles
  2. weights > 0
  3. Left weight < Right weight

You can use a simple exhaustive search defining every possible route. So you have a O(NxN) algoririthm. And then you will choose the shortest path. It is not a very smart solution, but it is effective.

But I suppose you want to be smarter than that, let's consider that if a particular node can be reached from two nodes, you can find the minimum of the weights at the two nodes plus the cost for arriving to the current node. You can consider this as an extension of the previous exhaustive search.

Remember that a DAG can be drawn in a line. For DAG linearization here's an interesting resource.

Now you have just defined a recursive algorithm.

MinimumPath(A,B) = MinimumPath(MinimumPath(A,C)+MinimumPath(A,D)+,MinimumPath(...)+MinimumPath(...))

Of course the starting point of recursion is 

MinimumPath(Source,Source)

which is 0 of course. As far as I know, there isn't an out of the box algorithm from boost to do this. But this is quite straightforward to implement it.

A good implementation is here.

If, for some reason, you do not have a DAG, Dijkstra's or Bellman-Ford should be used.

Upvotes: 1

pbible
pbible

Reputation: 1259

if I'm not mistaken, from the explanation this is really an optimal path problem not a search problem since the goal is known. In optimization I don't think you can avoid doing an exhaustive search if you want the optimal path and not an approximate path.

From the paper it seems like you are really subdividing a space many times then running the algorithm. This would reduce your N to closer to a constant in the context of the entire surface making O(N^2) not so bad.

That being said perhaps dynamic programming would be a good strategy where the N would be bounded by the difference between your start and goal node. Here is an example form genomic alignment. Just an illustration to give you an idea of how it works.

enter image description here

Construct a N by N array of cost values all set to 0 or some default.

   #
   For i in size N:
      For j in size N:
          #cost of getting here from i-1 or j-1
         cost[i,j] = min(cost[i-1,j] + i edge cost , cost[i,j-1] + j edge cost)

Once you have your table filled in, start at bottom right corner. Starting from your goal, Choose to go to the node with the lowest cost of getting there. Work your way backwards choosing the lowest value until you reach the start node (or rather the array entry corresponding to the start node). This should give you the optimal path very simply.

Dynamic programming works by solving the optimization on smaller sub-problems. In this case the sub-problems are optimal paths to preceding nodes. I think the rectangular nature of your graph makes this a good fit.

Upvotes: 0

Related Questions