8-puzzle | Solution of 8-puzzle problem using A * algorithm | Learning library

Yes, you can specify a custom compare function for priority_queue

It looks to me like you should only need to calculate the full Manhattan distance sum for an entire board once - for the first board. After that, you're creating new Board entities from existing ones by swapping two adjacent numbers. The total Manhattan distance on the new board will differ only by the sum of changes in Manhattan distance for these two numbers.

If one of the numbers is the blank (0), then the total distance changes by minus one or one depending on whether the non-blank number moved closer to its proper place or farther from it. If both of the numbers are non-blank, as when you're making "twins", the total distance changes by minus two, zero, or two.

Here's what I would do: add a manhattan_distance = None argument to Board.__init__. If this is not given, calculate the board's total Manhattan distance; otherwise simply store the given distance. Create your first board without this argument. When you create a new board from an existing one, calculate the change in the total distance and pass the result in to the new board. (The cached_manhattan becomes irrelevant.)

This should reduce the total number of calculations involved with distance by quite a bit - I'd expect it to speed things up by several times, more the larger your board size.

Use a heuristic, like A*. This is known to work well and there are many guides on it.

You have a typo. You've passed three lists:

Basically this line of code is wrong:

The problem is in Greedy::doGreedy and your usage of current.

The assignment current = greedyQueue.top(); creates a copy of the top object in the queue. Later, when you call vector childrenFound = current.expandNode();, all the returned states have parent pointers that refer to current. On the next loop iteration, you make that assignment to current again, changing the parent pointed to by all those returned states.

There isn't an easy fix with your code. You need to rethink how you store State objects so that the parent objects stay around and unmodified. Often this sort of thing is done with a stack or list, adding each node to the end and popping them off to move up to the parent.

I think this is OK for two reasons

1) You are only changing the behaviour in the case of ties, so all you are doing is selecting one possible execution path from a larger set of execution paths which are possible with the original version.

2) You preserve the property that if you retrieve the goal node from the open List, every other node in the open has G-Cost + H-Cost at least as expensive as that of the node you have just retrieved, and so must lead to a path to the goal node at least as expensive as the node you have just retrieved.

By favoring nodes with low heuristic cost in the case of ties, you are favoring any goal nodes in the case of ties, so I guess you might retrieve the goal node slightly earlier and so finish slightly earlier.

The problem is that you are creating a shallow copy of the current puzzle, so you change the current puzzle in each loop. You should, instead create a deep copy of the current puzzle, and leave the current puzzle intact. I don't know the full implementation of your Puzzle class, but you may want to check your constructor and setter methods.

Create a new constructor for Puzzle: