Problem with slide block puzzle

Question

Hello:
I am doing a project that solve slide-block puzzles. My program take two common line arguments. One is a file specifying the initial configuration while the other specify goal configuration. My idea is to use an arrayList<block > to represent a configuration with each element being a block, for each block, I stores all possible configurations after moving the block in a Hashset and Stack. I check if the goal has been reached after each move, if not, go moving next one. If the configuration has been seen before, which indicates a dead end, I pop the stack to backtrack the most recent the branch and take another path.
Unfortunately, the algorithm I came up does not work.
Can anyone propose a psudocode for me?
Also, my program should print out all moves directly towards the goal but I can not figure out how to only print out the moves directly towards the goal and avoid printing those leading to dead end.
You can see specification http://nifty.stanford.edu/2007/clancy-slidingblocks/proj3.html.
I will be really really appreciated.

Answer 1

Well, that was harder than I thought!
Anyway, the algorithm can be quite simple: a BFS finds a solution pretty fast. Here's some pseudo code:
public class Solver {
    private Set<Integer> alreadyFormedTrays; // A set of already formed trays
    private List<Block> goalList;            // The final goal(s)
    private boolean foundSolution  = false;  // A flag flipped to true once we find a solution
    private Tray startTray;                  // The initial tray
    public Solver(String[] tray, String[] goals) {
        alreadyFormedTrays = new HashSet<Integer>();
        goalList = new ArrayList<Block>();
        buildTray(tray);
        buildGoals(goals);
    private void buildGoals(String[] goalsData) {
        // Fill the 'goalList'.
    private void buildTray(String[] trayData) {
        // Create the first tray: 'startTray'.
    private boolean goalsReached(Tray aTray) {
        // Check wether we have reached our goal(s).
    public void solve() {
        alreadyFormedTrays.add(startTray.hashCode());
        System.out.println("START=\n"+startTray);
        solve(startTray);
    private void solve(Tray aTray) {
        IF we found a solution, stop looping END IF
        IF 'aTray' reached our goal(s)
            foundSolution <- true
            print the path 'aTray' has taken
            stop looping
        END IF
        'nextTrays' <- all next trays that can be formed from 'aTray'
        FOR every Tray 'T' in 'nextTrays' DO
            'hash' <- a hash of 'T'
            IF 'hash' is not yet present in 'alreadyFormedTrays'
                add 'hash' in 'alreadyFormedTrays'
                make a recursively call with 'T' as a parameter
            ENDIF
        ENDFOR
    public static void main(String[] args) {
        String[] trayFile = {
                "5 4",
                "2 1 0 0",
                "2 1 0 3",
                "2 1 2 0",
                "2 1 2 3",
                "2 2 1 1",
                "1 2 3 1",
                "1 1 4 0",
                "1 1 4 1",
                "1 1 4 2",
                "1 1 4 3"
        String[] goalFile = {
                "2 2 3 1"
        Solver s = new Solver(trayFile, goalFile);
        s.solve();
}As I said: the algorithm isn't that hard, the tricky part comes in finding all possible Trays from a given Tray X and making copies based on X.
Here are some UML diagrams of the classes I used:
|                                      |
| + Tray                               |
|______________________________________|
|                                      |
| ROWS: int                            |
| COLUMNS: int                         |
| - freeSpaces: byte[][]               |
| blocks: List<Block>                  |
| path: List<Atom[]>                   |
|______________________________________|
|                                      |
| + Tray(r: int, c: int): << constr >> |
| + Tray(tray: Tray): << constr >>     |
| + addBlock(b: Block): boolean        |
| + generateNextTrays(): List<Tray>    |
| + removeBlock(b: Block): void        |
|______________________________________|
|                                                                                          |
| + Block                                                                                  |
|__________________________________________________________________________________________|
|                                                                                          |
| HEIGHT: int                                                                              |
| WIDTH: int                                                                               |
| name: char                                                                               |
| atoms: List<Atom>                                                                        |
|__________________________________________________________________________________________|
|                                                                                          |
| + Block(n: char, height: int, width: int, startRow: int, startColumn: int): << constr >> |
| + Block(b: Block): << constr >>                                                          |
| - buildAtoms(startRow: int, startColumn: int): void                                      |
| + getUpperLeft(): Atom                                                                   |
| + move(m: Move): void                                                                    |
|__________________________________________________________________________________________|
|                                      |
| + Atom                               |
|______________________________________|
|                                      |
| row: int                             |
| column: int                          |
|______________________________________|
|                                      |
| + Atom(r: int, c: int): << constr >> |
| + Atom(a: Atom): << constr >>        |
| + move(m: Move): void                |
|______________________________________|I removed the equals(...), hashCode() and toString() methods for clarity, you should implement them, of course.
The Move class you see in there is an enum, and looks like this:
public enum Move {
    UP    (-1,  0),
    RIGHT ( 0,  1),
    DOWN  ( 1,  0),
    LEFT  ( 0, -1);
    final int deltaRow, deltaColumn;
    private Move(int dr, int dc) {
        deltaRow = dr;
        deltaColumn = dc;
}If you have any questions about the methods/variables in the class diagrams, feel free to post back.
Good luck.