深度优先搜索：能否走出迷宫

题目

一个$m\times n$的迷宫里有很多激光，用其起点和终点坐标$(x_1,y_1,x_2,y_2)$来表示。有激光的地方不能通过。当起点为$(0,0)$，终点为$(m,n)$，且移动只能为上下左右各一个单位，问能否从起点到达终点。输入包括$m$和$n$，接着是激光的个数，每个激光的使用4个坐标表示。如果能够走出迷宫输出1，否则输出0。

• 测试输入
  100 80
  3
  10 2 8 25
  44 12 6 6
  5 6 10 51
• 测试输出
  1

分析

如果能走出迷宫，只需要找到其中的一条路径即可，所以适合用深度优先搜索。而广度优先搜索会去找所有路径中最短的，所以会在较大规模的迷宫中消耗较长的时间。
深度优先搜索在此问题中就是一种回溯法，具体思路是

1. 一旦搜索到一个可行点，立刻按照纵深方向搜索下一个可行点，如果这个点就是终点，则可以走出迷宫返回成功；
2. 每个可行点都要进行标记，保证之后不重复走已经标记的可行点；
3. 一旦发现当前点没有下一个可行点时，就从当前点退回到上一个可行点，从上一个可行点继续搜索可行点；
4. 如果上一个可行点仍然没有可行点，则一直退回直到某个最近点可以继续搜索可行点；
5. 如果一直退回到起点都不能搜索到下一个可行点，那么不能走出迷宫返回失败。

深度优先搜索可以使用递归的方式简单实现，而非递归的方式更能展现其搜索轨迹。非递归过程需要使用栈来保存搜索点，一旦搜索到可行点立刻入栈，并从此点纵深搜索下一个可行点；而如果没有下一个可行点，则当前点出栈，从上一个可行点继续搜索。

具体到本题，需要将激光经过的地方都标记为不可行点，然后按照深度优先搜索来寻找一条路径。但激光是一条直线不好表示为不可行点，我们可以将直线转化为一条向上凸起的折线，这样的折线只有两种形态，可见这样的转化并不会改变最后结果。

代码

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

public class LaserMaze {
    static final int[][] MOVES = new int[][]{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};// 优先向右下方向前进

    static class Pos {
        int x;
        int y;

        Pos(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public boolean equals(Object obj) {
            return ((Pos) obj).x == this.x && ((Pos) obj).y == this.y;
        }
    }
    // 广度优先搜索会超时
    static int bfs(Pos start, Pos end, boolean[][] visited, int m, int n) {
        Queue<Pos> queue = new ArrayDeque<>(m * n);
        queue.add(start);
        Pos cur;
        while (!queue.isEmpty()) {
            cur = queue.remove();
            if (cur.equals(end)) return 1;
            visited[cur.x][cur.y] = true;
            for (int[] step : MOVES) {
                int x = cur.x + step[0];
                int y = cur.y + step[1];
                if (x >= 0 && x <= n && y >= 0 && y <= m && !visited[x][y]) {
                    Pos nextPos = new Pos(x, y);
                    queue.add(nextPos);
                }
            }
        }
        return 0;
    }
    // 深度优先搜索递归实现
    static int dfs(Pos cur, Pos end, boolean[][] visited, int m, int n) {
        if (cur.equals(end)) return 1;// 找到一条路径就返回
        visited[cur.x][cur.y] = true;// 先对当前点标记，对已经走过的位置不重复走
        for (int[] step : MOVES) {
            int x = cur.x + step[0];
            int y = cur.y + step[1];
            if (x >= 0 && x <= n && y >= 0 && y <= m && !visited[x][y]) {
                Pos next = new Pos(x, y);
                int ret = dfs(next, end, visited, m, n);// 对下一个可行点立刻纵深搜索
                if (ret == 1) return 1;// 如果找到一条路径则立即返回，否则寻找下一个可行点
            }
        }
        return 0;
    }
    // 深度优先搜索非递归实现
    static int dfs2(Pos start, Pos end, boolean[][] visited, int m, int n) {
        Stack<Pos> stack = new Stack<>();
        stack.push(start);
        visited[start.x][start.y] = true;// 入栈点立刻标记
        Pos cur;
        boolean hasNext;
        while (!stack.isEmpty()) {
            cur = stack.peek();
            if (cur.equals(end)) return 1;// 找到一条路径就返回
            hasNext = false;// 有没有下一个可行点
            for (int[] step : MOVES) {
                int x = cur.x + step[0];
                int y = cur.y + step[1];
                if (x >= 0 && x <= n && y >= 0 && y <= m && !visited[x][y]) {
                    Pos next = new Pos(x, y);
                    stack.push(next);
                    visited[x][y] = true;// 入栈点立刻标记
                    hasNext = true;
                    break;// 对找到的下一个可行点立刻纵向搜索
                }
            }
            if (!hasNext) stack.pop();// 没有下一个可行点则当前点出栈
        }
        return 0;
    }

    static void makeLaser(int[][] lasers, boolean[][] visited) {
        for (int[] aLaser : lasers) {// 保证折线是上凸的
            if (aLaser[3] > aLaser[1]) {
                for (int i = aLaser[1]; i <= aLaser[3]; i++) {
                    visited[aLaser[0]][i] = true;
                }
                for (int i = aLaser[0]; i <= aLaser[2]; i++) {
                    visited[i][aLaser[3]] = true;
                }
            } else {
                for (int i = aLaser[0]; i <= aLaser[2]; i++) {
                    visited[i][aLaser[3]] = true;
                }
                for (int i = aLaser[3]; i <= aLaser[1]; i++) {
                    visited[aLaser[0]][i] = true;
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        int nlaser = sc.nextInt();
        int[][] lasers = new int[nlaser][4];
        boolean[][] visited = new boolean[n + 1][m + 1];
        for (int i = 0; i < nlaser; i++) {
            int x1 = sc.nextInt();
            int y1 = sc.nextInt();
            int x2 = sc.nextInt();
            int y2 = sc.nextInt();
            if (x1 < x2) {// 保证laser[0]<laser[2]
                lasers[i][0] = x1;
                lasers[i][1] = y1;
                lasers[i][2] = x2;
                lasers[i][3] = y2;
            } else {
                lasers[i][0] = x2;
                lasers[i][1] = y2;
                lasers[i][2] = x1;
                lasers[i][3] = y1;
            }
        }
        makeLaser(lasers, visited);
        Pos start = new Pos(0, 0);
        Pos end = new Pos(n, m);
        System.out.println(dfs(start, end, visited, m, n));
    }
}