Java數據結構之回溯算法的遞歸應用迷宮的路徑問題

一、簡介

　　回溯法的基本思想是：對一個包括有很多結點，每個結點有若干個搜索分支的問題，把原問題分解為對若干個子問題求解的算法。當搜索到某個結點、發現無法再繼續搜索下去時，就讓搜索過程回溯（即退回）到該結點的前一結點，繼續搜索這個結點的其他尚未搜索過的分支；如果發現這個結點也無法再繼續搜索下去時，就讓搜索過程回溯到這個結點的前一結點繼續這樣的搜索過程；這樣的搜索過程一直進行到搜索到問題的解或搜索完了全部可搜索分支沒有解存在為止。

　　該方法可以使用堆棧實現。也可以使用遞歸實現，遞歸實現的話代碼比較簡單，較難理解建議自己打斷點一步步跟蹤理解

//=============

/**
 * 回溯法解決，迷宮算法
 * 
 * @author MIX
 * 
 */
public class MyMaze {

    private static int startPosI; // 入口的i下標
    private static int startPosJ; // 入口的j下標
    private static int endPosI; // 出口的j下標
    private static int endPosJ; // 出口的j下標

    // 設置迷宮入口的坐標
    public void setStart(int startPosI, int startPosJ) {

        MyMaze.startPosI = startPosI;
        MyMaze.startPosJ = startPosJ;
    }

    // 設置迷宮出口的坐標
    public void setEnd(int endPosI, int endPosJ) {

        MyMaze.endPosI = endPosI;
        MyMaze.endPosJ = endPosJ;
    }

    // 迷宮搜索通路的算法
    /**
     * 
     * @param cell
     *            迷宮地圖
     * @param i
     *            入口的i坐標
     * @param j
     *            入口的j坐標
     */
    public static void visited(int[][] cell, int i, int j) {
        // 表示此路為通
        /*
         * 該標記記為走過該路徑，一旦該路徑為通路且走到了該路徑那么就將該位置置為1
         */
        cell[i][j] = 1;
        String oriention = null;
        if (i == endPosI && j == endPosJ) { // 找到了出口
            System.out.println("找到一條通路");
            for (int m = 0; m < cell.length; m++) {
                for (int n = 0; n < cell[i].length; n++) {
                    if (cell[m][n] == 2) {
                        System.out.print("2");
                    } else if (cell[m][n] == 1) {
                        System.out.print("*");
                    } else {
                        System.out.print(" ");
                    }
                }
                System.out.println();
            }
        }

        // 向左邊尋找通路
        if (cell[i][j - 1] == 0) {
            oriention = "left";
            visited(cell, i, j - 1);
        }
        // 向右尋找通路
        if (cell[i][j + 1] == 0) {
            oriention = "right";
            visited(cell, i, j + 1);
        }
        // 向上尋找通路
        if (cell[i - 1][j] == 0) {
            oriention = "up";
            visited(cell, i - 1, j);
        }
        // 向下尋找通路
        if (cell[i + 1][j] == 0) {
            oriention = "down";
            visited(cell, i + 1, j);
        }
        /*
         * 一旦該路徑走到了死胡同里，清理走過的路徑將當前位置重新標志為1，推出當前遞歸的迭代堆棧，返回上一次，繼續
         * 在當前函數里面的應用主要是清理之前走過的但是被標記為1的位置，將該位置重新置為0，以便下一次的位置可以訪問
         */
        oriention = "無知的我";
        cell[i][j] = 0;

    }

    public static void main(String[] args) {
        // 初始化一個迷宮地圖
        int[][] maze = { { 2, 2, 2, 2, 2, 2, 2, 2, 2 },
                { 2, 0, 0, 0, 0, 0, 0, 0, 2 }, { 2, 0, 2, 2, 0, 2, 2, 0, 2 },
                { 2, 0, 2, 0, 0, 2, 0, 0, 2 }, { 2, 0, 2, 0, 2, 0, 2, 0, 2 },
                { 2, 0, 0, 0, 0, 0, 2, 0, 2 }, { 2, 2, 0, 2, 2, 0, 2, 2, 2 },
                { 2, 0, 0, 0, 0, 0, 0, 0, 2 }, { 2, 2, 2, 2, 2, 2, 2, 2, 2 } };

        // MyMaze cell = new MyMaze();
        // cell.setStart(1, 1);
        // cell.setEnd(7, 7);
        // cell.visited(maze, startPosI, startPosI);
        int[][] maze2 = { { 2, 2, 2, 2 }, { 2, 0, 0, 2 }, { 2, 0, 0, 2 },
                { 2, 2, 2, 2 } };
        MyMaze cell = new MyMaze();
        cell.setStart(1, 1);
        cell.setEnd(2, 2);
        cell.visited(maze2, startPosI, startPosJ);
    }

}

//上面代碼里面的測試代碼我是用了一個比較簡單的4*4矩陣進行測試，方便斷點觀察，理解該算法的思路。

//這里其實和遞歸方法的方法棧應用有點類似。