P1605 迷宫 —— DFS

最新推荐文章于 2025-03-08 02:26:05 发布

原创最新推荐文章于 2025-03-08 02:26:05 发布 · 240 阅读

0 ·

CC 4.0 BY-SA版权

Algorithms 同时被 3 个专栏收录

21 篇文章

订阅专栏

DFS

7 篇文章

订阅专栏

经典问题

3 篇文章

订阅专栏

本文介绍了一种使用深度优先搜索(DFS)算法来计算从起点到终点的所有可能路径数量的方法。通过递归地探索迷宫中每个可达位置并标记已访问节点避免重复计算，最终得出所有可能的路径总数。

import java.util.Scanner;

public class Main {
    static int[][] judge = new int[6][6];
    static int[][] map = new int[6][6];
    static int[] dx = { 0, 0, 1, -1 };
    static int[] dy = { 1, -1, 0, 0 };
    static int N, M, T;
    static int sx, sy, fx, fy;
    static int sum = 0;

    static void dfs(int x, int y) {
        if (x == fx && y == fy) {
            sum++;
            return;
        } else {
            for (int i = 0; i <= 3; i++) {
                if (judge[x + dx[i]][y + dy[i]] == 0
                        && map[x + dx[i]][y + dy[i]] == 1) {
                    judge[x][y] = 1;
                    dfs(x + dx[i], y + dy[i]);
                    judge[x][y] = 0;
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        M = sc.nextInt();
        T = sc.nextInt();
        sx = sc.nextInt();
        sy = sc.nextInt();
        fx = sc.nextInt();
        fy = sc.nextInt();
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= M; j++) {
                map[i][j] = 1;
            }
        }
        for (int i = 1; i <= T; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            map[x][y] = 0;
        }
        dfs(sx, sy);
        System.out.println(sum);
    }
}