Leetcode刷题c++之864. 获取所有钥匙的最短路径

最新推荐文章于 2024-05-20 15:29:54 发布

DRX.Deft

最新推荐文章于 2024-05-20 15:29:54 发布

阅读量130

点赞数

文章标签： c++ leetcode 开发语言

原文链接：https://leetcode.cn/problems/shortest-path-to-get-all-keys/solution/by-lcbin-mk6o/

版权

题目描述：

给定一个二维网格 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。

首先，我们遍历二维网格，找到起点位置 (si, sj)，并统计钥匙的个数 k。

然后，我们可以使用广度优先搜索 BFS来解决本题。由于钥匙的个数范围是 [1, 6]，我们可以用一个二进制数来表示钥匙的状态，其中第 i 位为 1 表示第 i 把钥匙已经获取到了，为 0 表示第 i 把钥匙还没有获取到。

比如，以下例子中，共有 4 个二进制位为 1，表示 'b', 'c', 'd', 'f' 4 把钥匙已经获取到了。

1 0 1 1 1 0

^ ^ ^ ^

f d c b

我们定义一个队列 q 来存储当前位置以及当前拥有的钥匙的状态，即 (i, j, state)，其中 (i, j) 表示当前位置，state 表示当前拥有的钥匙的状态，即 state 的第 i 位为 1 表示当前拥有第 i 把钥匙，否则表示当前没有第 i 把钥匙。

另外，定义哈希表或数组 vis 记录当前位置以及当前拥有的钥匙的状态是否已经被访问过，如果访问过，则不需要再次访问。vis[i][j][state] 表示当前位置为 (i, j)，当前拥有的钥匙的状态为 state 时，是否已经被访问过。

我们从起点 (si, sj) 出发，将其加入队列 q，并将 vis[si][sj][0] 置为 true，表示起点位置以及拥有的钥匙的状态为 0 时已经被访问过。

在广度优先搜索的过程中，我们每次从队首取出一个位置 (i, j, state)，并判断当前位置是否为终点，即当前位置是否拥有所有的钥匙，即 state 的二进制表示中的 1 的个数是否为 k。如果是，将当前步数作为答案返回。

否则，我们从当前位置出发，往上下左右四个方向走，如果可以走到下一个位置 (x, y)，则将 (x, y, nxt) 加入队列 q，其中 nxt 表示下一个位置的钥匙的状态。

这里 (x, y) 首先需要满足在网格范围内，即 0≤x<m 且 n0≤y<n。其次，如果 (x, y) 位置是墙壁，即 grid[x][y] == '#'，或者 (x, y) 位置是锁，但我们没有对应的钥匙，即 grid[x][y] >= 'A' && grid[x][y] <= 'F' && (state >> (grid[x][y] - 'A') & 1) == 0)，则不能走到位置 (x, y)。否则，我们可以走到位置 (x, y)。

搜索结束，没能找到所有的钥匙，返回−1。

代码：

class Solution {
public:
    const static inline vector<int> dirs = {-1, 0, 1, 0, -1};

    int shortestPathAllKeys(vector<string>& grid) {
        int m = grid.size(), n = grid[0].size();
        int k = 0;
        int si = 0, sj = 0;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                char c = grid[i][j];
                // 累加钥匙数量
                if (islower(c)) ++k;
                // 起点
                else if (c == '@') si = i, sj = j;
            }
        }
        queue<tuple<int, int, int>> q{{{si, sj, 0}}};
        vector<vector<vector<bool>>> vis(m, vector<vector<bool>>(n, vector<bool>(1 << k)));
        vis[si][sj][0] = true;
        int ans = 0;
        while (!q.empty()) {
            for (int t = q.size(); t; --t) {
                auto [i, j, state] = q.front();
                q.pop();
                // 找到所有钥匙，返回当前步数
                if (state == (1 << k) - 1) return ans;
                // 往四个方向搜索
                for (int h = 0; h < 4; ++h) {
                    int x = i + dirs[h], y = j + dirs[h + 1];
                    // 在边界范围内
                    if (x >= 0 && x < m && y >= 0 && y < n) {
                        char c = grid[x][y];
                        // 是墙，或者是锁，但此时没有对应的钥匙，无法通过
                        if (c == '#' || (isupper(c) && (state >> (c - 'A') & 1) == 0)) continue;
                        int nxt = state;
                        // 是钥匙，更新状态
                        if (islower(c)) nxt |= 1 << (c - 'a');
                        // 此状态未访问过，入队
                        if (!vis[x][y][nxt]) {
                            vis[x][y][nxt] = true;
                            q.push({x, y, nxt});
                        }
                    }
                }
            }
            // 步数加一
            ++ans;
        }
        return -1;
    }
};

作者：lcbin
链接：https://leetcode.cn/problems/shortest-path-to-get-all-keys/solution/by-lcbin-mk6o/
来源：力扣（LeetCode）