使用回溯递归算法生成迷宫时出错

时间:2013-04-07 18:07:42

标签: java recursion generator backtracking maze

我正在使用递归回溯算法创建迷宫生成器。但是,我的问题是每次运行程序时都会产生以下结果:

1 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 0 1 1 1
0 0 0 0 0 0 1 1 1 1
0 0 0 0 0 1 1 1 1 1
0 0 0 0 1 1 1 1 1 1
0 0 0 1 1 1 1 1 1 1
0 0 1 1 1 1 1 1 1 1
0 1 1 1 1 1 1 1 1 1
0 1 1 1 1 1 1 1 1 1

我的代码背景: 构造函数用0填充迷宫int数组,并在结束位置(0,0)放置1,然后调用backtrackGenerateMaze()方法随机生成迷宫。我认为问题可能是我没有某种墙,这可能会让奇怪的事情发生。此外,对于方向:0 =向上,1 =向右,2 =向下,& 3 =离开。希望有所帮助。

这是我的代码(对不起,我已经尝试使用注释来调试它了):

public class Maze {

    private int width, length;
    private int[][] maze;

    public Maze(int rows, int columns) {
        width = columns;
        length = rows;

        maze = new int[rows][columns];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                maze[i][j] = 0;
            }
        }
        maze[0][0] = 1;

        backtrackGenerateMaze(rows - 1, columns - 1, 1);
    }

    /*
    * THE PROBLEM MUST BE HERE IN THE backtrackGenerateMaze() METHOD
    */
    private void backtrackGenerateMaze(int rows, int columns, int moveLength) {
        if (rows == 0 && columns == 0) {
            System.out.println("rows = " + rows);
            System.out.println("length = " + length);
            System.out.println("columns = " + columns);
            System.out.println("width = " + width);
            return;
        }

        int[] randDirs = generateRandomDirections();

        for (int dir : randDirs) {
            System.out.println("dir == " + dir);
            System.out.println("rows == " + rows);
            System.out.println("columns == " + columns + "\n");
            if (dir == 0) {
                System.out.println("rows - moveLength == " + (rows - moveLength));
                 System.out.println("valid(rows - moveLength, columns) == " + (valid(rows - moveLength, columns)));
                 System.out.println("isInRange(0, length, rows - moveLength, false) == " + (isInRange(0, length, rows - moveLength, false)));

                if (valid(rows - moveLength, columns)
                    && isInRange(0, length, rows - moveLength, false)
                    && maze[rows - moveLength][columns] != 1) {
                    System.out.println("IF 0 is TRUE");
                    for (int i = 1; i <= moveLength; i++) {
                        maze[rows - moveLength][columns] = 1;
                    }
                    maze[rows][columns] = 1;
                    System.out.println("HERE 0");
                    backtrackGenerateMaze(rows - moveLength, columns, moveLength);
                }

                // System.out.println("RETURN DIR 0");
                // return;
            } else if (dir == 1) {
                System.out.println("columns + moveLength = " + (columns + moveLength));
                System.out.println("valid(rows, columns + moveLength) = " + (valid(rows, columns + moveLength)));
                System.out.println();

                if (valid(rows, columns + moveLength)) {
                    System.out.println("VALID 1 is TRUE");
                    if (isInRange(0, width, columns + moveLength, false)) {
                        System.out.println("isInRange() 1 is TRUE");
                        if (maze[rows][columns + moveLength] != 1) {
                            System.out.println("square != 1 is TRUE");
                            System.out.println("IF 1 is TRUE");
                            for (int i = 1; i <= moveLength; i++) {
                                maze[rows][columns + moveLength] = 1;
                            }
                            maze[rows][columns] = 1;
                            System.out.println("HERE 1");
                            backtrackGenerateMaze(rows, columns + moveLength, moveLength);
                        }
                    }
                }

                System.out.println("RETURN DIR 1");
                return;
            } else if (dir == 2) {
                if (valid(rows + moveLength, columns)
                    && isInRange(0, length, rows + moveLength, false)
                    && maze[rows + moveLength][columns] != 1) {
                    System.out.println("IF 2 is TRUE");
                    for (int i = 1; i <= moveLength; i++) {
                        maze[rows + moveLength][columns] = 1;
                    }
                    maze[rows][columns] = 1;
                    System.out.println("HERE 2");
                    backtrackGenerateMaze(rows + moveLength, columns, moveLength);
                }

                System.out.println("RETURN DIR 2");
                return;
            } else if (dir == 3) {
                if (valid(rows, columns - moveLength)
                    && isInRange(0, width, columns - moveLength, false)
                    && maze[rows][columns - moveLength] != 1) {
                    System.out.println("IF 3 is TRUE");
                    for (int i = 1; i <= moveLength; i++) {
                        maze[rows][columns - moveLength] = 1;
                    }
                    maze[rows][columns] = 1;
                    System.out.println("HERE 3");
                    backtrackGenerateMaze(rows + moveLength, columns - moveLength, moveLength);
                }

                System.out.println("RETURN DIR 3");
                return;
            }
        }
        System.out.println("--------------------");
    }

    public int[] generateRandomDirections() {
        ArrayList<Integer> rands = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            rands.add(i);
        }
        Collections.shuffle(rands);

        int[] ret = new int[4];
        for (int i = 0; i < rands.size(); i++) {
            ret[i] = rands.get(i);
        }
        return ret;
    }

    private boolean valid(int row, int column) {
        return isInRange(0, maze.length - 1, row, true)
                && isInRange(0, maze[0].length - 1, column, true);
    }

    private boolean isInRange(int start, int end, int toCheck,
            boolean inclusive) {
        if (inclusive) {
            return (toCheck >= start && toCheck <= end);
        }
        return (toCheck > start && toCheck < end);
    }

    @Override
    public String toString() {
        String ret = "";
        for (int i = 0; i < maze.length; i++) {
            for (int j = 0; j < maze[0].length; j++) {
                ret += maze[i][j] + " ";
            }
            ret += "\n";
        }
        return ret;
    }
}

...这是我用来运行它的主要方法:

public class MazeGame {

    private static ArrayList<Maze> mazes = new ArrayList<>();
    private static final int MAZE_SIZE = 10, NUM_MAZES = 1;

    public static void main(String[] args) {
        Maze temp;
        for (int i = 0; i < NUM_MAZES; i++) {
            temp = new Maze(MAZE_SIZE, MAZE_SIZE);
            System.out.println(temp);
            mazes.add(temp);
        }
    }
}

非常感谢任何帮助。

1 个答案:

答案 0 :(得分:0)

此代码在此处运行,输出:

dir == 2
rows == 9
columns == 9

RETURN DIR 2
1 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 

绝对不是你说的......