Shortest cost path

Question

I have to find the shortest path from point D to R. These are fixed points. This is an example of a situation:

enter image description here

The box also contains walls, through which you cannot pass across them, unless you break them. Each wall break costs you, let's say "a" points, where "a" is a positive integer. Each move which doesn't involve a wall, costs you 1 point.

The mission is to find out of all the paths of minimum cost, the one with the least number of broken walls.

Since, the width of the box can go up to 100 cells, it's irrelevant to use backtracking. It's too slow. The only solution I came up is this one:

Go east or south if there are no walls
If south has a wall, check if west has wall. If west has wall, break south wall. If west doesn't have wall, go west, until you find a south cell without wall. Repeat this process with south and east until you exceed the cost of a broken wall in this order. If path from west goes into the same place as if I had broken the south wall and costs the same or less than "a" points, then use this path, else brake south wall.
If nothing above encounters, brake a south or east wall, depending on the box boundary.

Repeat steps 1, 2, 3 till the "passenger" arrives in point R. Between these 3 steps, there are "else-if" relations.

Can you come up with a better problem algorithm? I program in C++.

What exactly do you mean by "find out the path which has a minimum cost and minimum broken walls"? Something like "out of all the paths of minimum cost, one with the least number of broken walls"? — harold, Feb 23 '14 at 16:44
Yes, out of all the paths of minimum cost, choose the one with the least number of broken walls. — Robert Lucian Chiriac, Feb 23 '14 at 16:47
Do I know where all the walls are when I set out from D? Or do I discover them only when I reach them? — Beta, Feb 23 '14 at 16:56

score 3 · Accepted Answer · answered Feb 23 '14 at 17:29

3

Use Dijkstra, but for costs give it 1 for a move that doesn't break a wall, and (a+0.00001) for breaking a wall. Then Dijkstra will give you what you want, the path that breaks the fewest walls among all minimal-cost paths.

Conceptually, imagine a traveler who can jump over walls -- while keeping track of the cost -- and can also split into two identical travelers when faced with a choice of two paths, so as to take them both (take that, Robert Frost!). Only one traveler moves at a time, the one who has incurred the lowest cost so far. That one moves, and writes on the floor "I reached here at a cost of only x". If I find such a note already there, if I got there more cheaply I erase the old note and write my own; if that other traveler got there more cheaply I commit suicide.

answered Feb 23 '14 at 17:29

Beta

96,650
16
149
150

:( optimization by attrition – im so confused Feb 23 '14 at 17:35
Where does the extra 0.00001 comes from? Is it for keeping track of how many walls were "jumped over"? – Robert Lucian Chiriac Feb 23 '14 at 17:39
@RobertEagle: yes, that way in a contest between two paths with same real cost, the one involving more walls will lose. (And jumping over walls instead of breaking them is so one traveler can't benefit from the demolition performed by another.) – Beta Feb 23 '14 at 17:48
What is more efficient? Using Roy-Floyd (this one gives you the ability to actually know the path), A*, or it's subset, Dijkstra? – Robert Lucian Chiriac Feb 25 '14 at 15:07
@RobertEagle: It's simple enough to have each traveler remember its path. I'm not familiar with Roy-Floyd. Whether A* would be of much use depends on how **a** compares with the size of the maze. – Beta Feb 25 '14 at 16:13

score 1 · Answer 2 · answered Feb 23 '14 at 16:57

The two-part "cost first, then broken walls", can be represented as a pair (c, w) that is compared lexicographically. c is the cost, w is the number of broken walls. That makes it a "single thing" again (in some sense), so it's a thing that you can put into algorithms and so on that expect simply "a cost" (as an abstract thing that it may add an other cost to or compare to an other cost).

So we can just use A*, with a Manhattan Distance heuristic (perhaps there's something smarter that doesn't ignore walls completely, but this will work - underestimating the distance is admissible). The movement cost will, of course, not ignore walls. Neighbours will be all adjacent squares. All costs will be the pair I described above.

Mentioning the use of heuristics grants this answer more credibility than the others IMO. — E_net4, Feb 23 '14 at 17:01

score 0 · Answer 3 · answered Feb 23 '14 at 16:52

This could easily be modeled as a weighted graph and then apply Dijkstra's shortest path algorithm to it. Each square is a node. It is connected to the nodes of the squares it is adjacent to. The weight of the connections is either 1 or "a", based on whether there is a wall or not. This will get you the minimal cost. It's possible that the minimum cost and the minimum number of wall breaks could be different.

score 0 · Answer 4 · answered Feb 23 '14 at 16:56

Here is a general algorithm (you'll have to do the implementation yourself):

Convert the matrix into a weighted graph:

For each entry in the matrix, create a Vertex.
For each Vertex, create an array of Edges, one for each neighboring Vertex.
For each Edge, define a weight according to the cost of breaking the wall between the two Vertices that the Edge is connecting.

Then, run the Dijkstra's algorithm (http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm) on the graph, starting from Vertex D. As an output, you will have the shortest (cheapest) path from Vertex D to any other Vertex on the graph, including Vertex R.

Shortest cost path

4 Answers4