力扣每日一题：864. 获取所有钥匙的最短路径【bfs+状态压缩】

给定一个二维网格 grid ，其中：

• '.' 代表一个空房间
• '#' 代表一堵
• '@' 是起点
• 小写字母代表钥匙
• 大写字母代表锁

我们从起点开始出发，一次移动是指向四个基本方向之一行走一个单位空间。我们不能在网格外面行走，也无法穿过一堵墙。如果途经一个钥匙，我们就把它捡起来。除非我们手里有对应的钥匙，否则无法通过锁。

假设 k 为 钥匙/锁 的个数，且满足 1 <= k <= 6，字母表中的前 k 个字母在网格中都有自己对应的一个小写和一个大写字母。换言之，每个锁有唯一对应的钥匙，每个钥匙也有唯一对应的锁。另外，代表钥匙和锁的字母互为大小写并按字母顺序排列。

返回获取所有钥匙所需要的移动的最少次数。如果无法获取所有钥匙，返回 -1 。

 

示例 1：

输入：grid = ["@.a.#","###.#","b.A.B"]
输出：8
解释：目标是获得所有钥匙，而不是打开所有锁。

示例 2：

输入：grid = ["@..aA","..B#.","....b"]
输出：6

示例 3:

输入: grid = ["@Aa"]
输出: -1

 

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 30
• grid[i][j] 只含有 '.', '#', '@', 'a'-'f' 以及 'A'-'F'
• 钥匙的数目范围是 [1, 6] 
• 每个钥匙都对应一个 不同 的字母
• 每个钥匙正好打开一个对应的锁

分析 ： 把我整吐了这个东西，本来看到困难题，想明天的每日一题在来的，最后还是硬着头皮写了。题目意思：. :代表着空房间，@是起点，#代表着一堵墙没法走，小写字母代表着钥匙，大写字母代表着锁，每一把锁都有都应的钥匙，然后求出收集所有钥匙最短的路径。我么就先不考虑有钥匙和锁的情况，直接就是求最短的路径，那我们肯定就是用bfs去搜索，然后在目标位置停下。其实这道题也差不多就是这个意思，不过判断的情况有点多，写起来比较复杂。求最短路径的时候，我们总是会有一个标记数组，来标记是否走过了这个位置，但是这个房间是可以重复走，但是重复走是有条件的，就是钥匙的数量。如果重复走的钥匙的数量比上一次走钥匙的数量更多，那我们才可以走。那么钥匙的数量我们要怎么表示呢？可以进行状态压缩，用二进制来表示，第几位为1代表着第几把钥匙我们已经有了，可以用一个map来存储，映射对应的第几把锁。因此我们可以用一个三维的数组来表示当前的状态，（x,y,mask）其中 (x,y)(x, y)(x,y) 表示当前所处的位置，mask\textit{mask}mask 是一个二进制数，长度恰好等于网格中钥匙的数目，mask\textit{mask}mask 的第 iii 个二进制位为 111，当且仅当我们已经获得了网格中的第 iii 把钥匙。这样子我们就可以来进行广度搜索了，初始我们先把@起始点加进队列，然后往四个方向进行辐射，

 如果对应方向的字符为. 那么mask 的值不变

如多对应方向的是第i把钥匙，那么将mask的第i位置为1；

如果对应方向是第 iii 把锁，那么只有在 mask\textit{mask}mask 的第 iii 位为 111 时，才可以通过

当我们搜索到一个 mask\textit{mask}mask 每一个二进制都为 111 的状态时，说明获取了所有钥匙，此时就可以返回最短路作为答案。

下面AC代码：

class Solution {
    static int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public int shortestPathAllKeys(String[] grid) {
        int m = grid.length, n = grid[0].length();
        int sx = 0, sy = 0;
        Map<Character, Integer> keyToIndex = new HashMap<Character, Integer>();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i].charAt(j) == '@') {
                    sx = i;
                    sy = j;
                } else if (Character.isLowerCase(grid[i].charAt(j))) {
                    if (!keyToIndex.containsKey(grid[i].charAt(j))) {
                        int idx = keyToIndex.size();
                        keyToIndex.put(grid[i].charAt(j), idx);
                    }
                }
            }
        }

        Queue<int[]> queue = new ArrayDeque<int[]>();
        int[][][] dist = new int[m][n][1 << keyToIndex.size()];
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                Arrays.fill(dist[i][j], -1);
            }
        }
        queue.offer(new int[]{sx, sy, 0});
        dist[sx][sy][0] = 0;
        while (!queue.isEmpty()) {
            int[] arr = queue.poll();
            int x = arr[0], y = arr[1], mask = arr[2];
            for (int i = 0; i < 4; ++i) {
                int nx = x + dirs[i][0];
                int ny = y + dirs[i][1];
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx].charAt(ny) != '#') {
                    if (grid[nx].charAt(ny) == '.' || grid[nx].charAt(ny) == '@') {
                        if (dist[nx][ny][mask] == -1) {
                            dist[nx][ny][mask] = dist[x][y][mask] + 1;
                            queue.offer(new int[]{nx, ny, mask});
                        }
                    } else if (Character.isLowerCase(grid[nx].charAt(ny))) {
                        int idx = keyToIndex.get(grid[nx].charAt(ny));
                        if (dist[nx][ny][mask | (1 << idx)] == -1) {
                            dist[nx][ny][mask | (1 << idx)] = dist[x][y][mask] + 1;
                            if ((mask | (1 << idx)) == (1 << keyToIndex.size()) - 1) {
                                return dist[nx][ny][mask | (1 << idx)];
                            }
                            queue.offer(new int[]{nx, ny, mask | (1 << idx)});
                        }
                    } else {
                        int idx = keyToIndex.get(Character.toLowerCase(grid[nx].charAt(ny)));
                        if ((mask & (1 << idx)) != 0 && dist[nx][ny][mask] == -1) {
                            dist[nx][ny][mask] = dist[x][y][mask] + 1;
                            queue.offer(new int[]{nx, ny, mask});
                        }
                    }
                }
            }
        }
        return -1;
    }
}