2020安徽省程序设计大赛——收集圣物

思路介绍

典型的BFS问题，权重相等的图

代码展示

import java.util.*;

class Node {
    int x;
    int y;
    int key;

    public Node(int x, int y, int key) {
        this.x = x;
        this.y = y;
        this.key = key;
    }
}

public class Main {
    static int n, m, key;
    static final int N = 100;
    static char[][] GetChar = new char[N][N];
    static int[][] dist = new int[N][N];   //到某个点的最短距离
    static ArrayList<Integer> list = new ArrayList<>();
    static Queue<Node> queue = new ArrayDeque<>();

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();

        //读入地图
        for (int i = 0; i < n; i++) {
            GetChar[i] = sc.next().toCharArray();
        }
        //寻找起始位置，开始bfs
        ff:
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                if (GetChar[i][j] == 'S') {
                    bfs(i, j);
                    break ff;
                }
    }

    private static void bfs(int x, int y) {
        //这个点加入队列当中，将其改为障碍物
        queue.add(new Node(x, y, key = 0));
        GetChar[x][y] = '#';
        //起始距离为0
        dist[x][y] = 0;

        //定义偏移量
        int[] dx = {0, 1, 0, -1};
        int[] dy = {1, 0, -1, 0};

        //开始遍历
        while (!queue.isEmpty()) {
            Node head = queue.remove();
            for (int i = 0; i < 4; i++) {
                //加上偏移量
                int sx = dx[i] + head.x; //横坐标
                int sy = dy[i] + head.y;//纵坐标
                //这个点在范围内 满足各种条件
                if (sx >= 0 && sx < n && sy >= 0 && sy < m && GetChar[sx][sy] != '#') {
                    //分4种情况
                    /*1.有路 为 .*/
                    if (GetChar[sx][sy] == '.') {
                        dist[sx][sy] = dist[head.x][head.y] + 1;
                        GetChar[sx][sy] = '#';
                        queue.add(new Node(sx, sy, head.key));
                    }
                    /*2. 有钥匙 */
                    if (GetChar[sx][sy] == 'K') {
                        dist[sx][sy] = dist[head.x][head.y] + 1;
                        GetChar[sx][sy] = '#';
                        // 当前位置点的钥匙数加 1
                        queue.add(new Node(sx, sy, ++head.key));
                    }
                    /*3.有门的情况
                     * 一个钥匙最多可以开4个门 但是结果可能只在一个门后生效
                     * 判断上一个点是否满足进门要求 即 是否有钥匙 */
                    if (GetChar[sx][sy] == 'D' && head.key > 0) {
                        dist[sx][sy] = dist[head.x][head.y] + 1;
                        queue.add(new Node(sx, sy, --head.key));
                    }
                    /*4.找到圣物 直接返回最短路径*/
                    if (GetChar[sx][sy] == 'E') {
                        dist[sx][sy] = dist[head.x][head.y] + 1;
                        list.add(dist[sx][sy]);
                    }
                }
            }
        }
        if (!list.isEmpty()) {
            Collections.sort(list);
            System.out.println(list.get(0));
        } else System.out.println("Bug Maze!!!");

    }
}

重点解析

由于一个钥匙可以最多打开上下左右4个方向的门，但是只有一个最短的合法结果，那么在进行偏移量的定位时，从当前位置开始，将钥匙数量key同时加入遍历的队列当中即可。

结果展示（未AC）