迷宮問題

題目描述

定義一個二維數組N*M（其中2<=N<=10;2<=M<=10），如5 × 5數組下所示：
    int maze[5][5] = {
        0, 1, 0, 0, 0,
        0, 1, 0, 1, 0,
        0, 0, 0, 0, 0,
        0, 1, 1, 1, 0,
        0, 0, 0, 1, 0,};
它表示一個迷宮，其中的1表示牆壁，0表示能夠走的路，只能橫着走或豎着走，不能斜着走，要求編程序找出從左上角到右下角的最短路線。入口點爲[0,0],既第一空格是能夠走的路。

Input
    一個N × M的二維數組，表示一個迷宮。數據保證有惟一解,不考慮有多解的狀況，即迷宮只有一條通道。
Output
    左上角到右下角的最短路徑，格式如樣例所示。
Sample Input
    0 1 0 0 0
    0 1 0 1 0
    0 0 0 0 0
    0 1 1 1 0
    0 0 0 1 0
Sample Output
    (0, 0)
    (1, 0)
    (2, 0)
    (2, 1)
    (2, 2)
    (2, 3)
    (2, 4)
    (3, 4)
    (4, 4)

輸入描述

輸入兩個整數，分別表示二位數組的行數，列數。再輸入相應的數組，其中的1表示牆壁，0表示能夠走的路。數據保證有惟一解,不考慮有多解的狀況，即迷宮只有一條通道。

輸出描述

左上角到右下角的最短路徑，格式如樣例所示。

輸入例子

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

輸出例子

(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

算法實現

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * Declaration: All Rights Reserved !!!
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        Scanner scanner = new Scanner(Main.class.getClassLoader().getResourceAsStream("data.txt"));
        while (scanner.hasNext()) {
            int row = scanner.nextInt();
            int col = scanner.nextInt();
            int[][] matrix = new int[row][col];
            for (int i = 0; i < row * col; i++) {
                matrix[i / col][i % col] = scanner.nextInt();
            }

            System.out.print(mazeWayfinding(matrix));
        }

        scanner.close();
    }

    private static String mazeWayfinding(int[][] matrix) {
        List<String> result = new ArrayList<>();
        boolean[][] visited = new boolean[matrix.length][matrix[0].length];
        boolean[] find = new boolean[1];
        wayfinding(matrix, 0, 0, visited, find, result);

        StringBuilder builder = new StringBuilder();
        for (String s : result) {
            builder.append(s).append('\n');
        }

//        return builder.substring(0, builder.length() - 1);
        return builder.toString();
    }

    /**
     * 找迷宮路徑
     *
     * @param matrix  迷宮
     * @param x       當前的行號
     * @param y       當前的列號
     * @param visited 標記某個位置是否被訪問過了
     * @param find    是否已經找到
     * @param result  路徑標識
     */
    private static void wayfinding(int[][] matrix, int x, int y, boolean[][] visited, boolean[] find, List<String> result) {
        // 若是已經找到
        if (find[0]) {
            return;
        }

        // 位置超出了迷宮或者當前不置不可走，或者已經被訪問過了
        if (x < 0 || x >= matrix.length || y < 0 || y >= matrix[0].length
                || matrix[x][y] == 1 || visited[x][y]) {
            return;
        }

        // 到達終點
        // 若是已經到達右下角，而且右下角的位置能夠走
        if (x == matrix.length - 1 && y == matrix[0].length - 1 && matrix[x][y] == 0) {
            find[0] = true;
            visited[x][y] = true;
            // 添加座標的
            result.add("(" + x + "," + y + ")");
        }
        // 末到終點
        else {
            // 標記座標爲(x, y)位置已經被訪問過了
            visited[x][y] = true;
            result.add("(" + x + "," + y + ")");

            // 向前走
            wayfinding(matrix, x, y + 1, visited, find, result);
            // 若是已經找到就結束
            if (find[0]) {
                return;
            }

            // 向上走
            wayfinding(matrix, x - 1, y, visited, find, result);
            // 若是已經找到就結束
            if (find[0]) {
                return;
            }

            // 向後走
            wayfinding(matrix, x, y - 1, visited, find, result);
            // 若是已經找到就結束
            if (find[0]) {
                return;
            }

            // 向下走
            wayfinding(matrix, x + 1, y, visited, find, result);
            // 若是已經找到就結束
            if (find[0]) {
                return;
            }

            // 還原
            visited[x][y] = false;
            result.remove(result.size() - 1);
        }


    }
}