算法：迷宮問題

一、迷宮問題介紹

　　給定一個方陣表示迷宮，其中 1 表示能走的路，0 為障礙或走不通（死胡同），迷宮左上為出發點，迷宮右下角為終點。在迷宮中的移動方式只能橫着走或豎着走，不能斜着走，找出沖出發點到達出口有效路徑的迷宮（maze problem）問題。

二、回溯法簡單求解

　　給定迷宮：

　　迷宮的二維矩陣表示：

                {1，0，0，0}
                {1，1，0，1}
                {0，1，0，0}
                {1，1，1，1}        

　　以下是具有突出解決方案路徑的迷宮。

 

 　　以下是上述輸入矩陣的解決方案矩陣（程序的輸出）：

                {1，0，0，0}
                {1，1，0，0}
                {0，1，0，0}
                {0，1，1，1}    

回溯算法思想：

　　如果到達目的地，打印解決方案矩陣。若沒有到達目的地，則：

　　a）在解決方案矩陣中將當前單元格標記為 1；

　　b）沿水平方向向前移動並遞歸檢查是否這次移動解決了問題；

　　c）如果在上述步驟中選擇的舉動沒有導致解決方案 然后向下移動並檢查此舉是否可以解決；

　　d）如果以上解決方案均無效，則將該單元格取消標記為 0 （回溯）並返回 false。

    /**
     * 回溯法遞歸求解迷宮問題
     *
     * @param maze
     * @param x
     * @param y
     * @param sol
     * @return
     */
    private boolean solveMazeUtil(int[][] maze, int x, int y, int[][] sol) {
        /* 到達終點 */
        if (x == (N - 1) && y == (N - 1)) {
            sol[x][y] = 1;
            return true;
        }

        /* 每次檢查(x, y)是否能走 */
        if (isSafe(maze, x, y)) {
            /* 能走則標記該位置 */
            sol[x][y] = 1;

            /* 沿x方向向前移動 */
            if (solveMazeUtil(maze, x + 1, y, sol)) {
                return true;
            }

            /* 如果沿x方向移動沒有給出解，則沿y方向向下移動 */
            if (solveMazeUtil(maze, x, y + 1, sol)) {
                return true;
            }

            /* 如果以上動作均無效，則回溯：將(x，y)標記為解決方案路徑的一部分記為不可行 */
            sol[x][y] = 0;
            return false;
        }

        return false;
    }

本文源代碼：

package algorithm;

public class RatMaze {
    /* 迷宮規模 */
    private static int N;

    /**
     * 打印解矩陣
     *
     * @param sol
     */
    private void printSolution(int[][] sol) {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                System.out.print(" " + sol[i][j] + " ");
            }
            System.out.println();
        }
    }

    /**
     * 判斷當前路勁是否可行
     *
     * @param maze
     * @param x
     * @param y
     * @return
     */
    private boolean isSafe(int[][] maze, int x, int y) {
        return (x >= 0 && x < N && y >= 0 && y < N && maze[x][y] == 1);
    }

    /**
     * 解決迷宮問題, 有則打印解矩陣
     *
     * @param maze
     * @return
     */
    private boolean solveMaze(int[][] maze) {
        int[][] sol = new int[N][N];
        if (!solveMazeUtil(maze, 0, 0, sol)) {
            System.out.println("Solution doesn't exist");
            return false;
        }
        printSolution(sol);
        return true;
    }

    /**
     * 回溯法遞歸求解迷宮問題
     *
     * @param maze
     * @param x
     * @param y
     * @param sol
     * @return
     */
    private boolean solveMazeUtil(int[][] maze, int x, int y, int[][] sol) {
        /* 到達終點 */
        if (x == (N - 1) && y == (N - 1)) {
            sol[x][y] = 1;
            return true;
        }

        count++;
        /* 每次檢查(x, y)是否能走 */
        if (isSafe(maze, x, y)) {
            /* 能走則標記該位置 */
            sol[x][y] = 1;

            /* 沿x方向向前移動 */
            if (solveMazeUtil(maze, x + 1, y, sol)) {
                return true;
            }
            
            /* 如果沿x方向移動沒有給出解，則沿y方向向下移動 */
            if (solveMazeUtil(maze, x, y + 1, sol)) {
                return true;
            }

            /* 如果以上動作均無效，則回溯：將(x，y)標記為解決方案路徑的一部分記為不可行 */
            sol[x][y] = 0;
            return false;
        }

        return false;
    }

    public static void main(String[] args) {
        RatMaze ratMaze = new RatMaze();
        int[][] maze = {
                { 1, 0, 0, 0 },
                { 1, 1, 1, 0 },
                { 0, 1, 0, 0 },
                { 1, 1, 1, 1 }
        };
        N = maze.length;
        ratMaze.solveMaze(maze);
    }
}