给定一个二维网格 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]
每个钥匙都对应一个 不同 的字母
每个钥匙正好打开一个对应的锁
来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/shortest-path-to-get-all-keys
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
class Solution {
public:
int shortestPathAllKeys(vector<string>& grid) {
int m = grid.size(), n = grid[0].size();
//题目要求,grid里面存放的是一个个字符串(每一行),m表示有多少个字符串也就是这个图有几行,n表示每个字符串拥有字符的个数(即多少列),图为m*n
int sx = 0, sy = 0; //定义sx,sy为起点坐标
unordered_map<char, int> key_to_idx; // 定义一个无序map存放对应的char和int (拿钥匙的判据)
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) { // 对整个图进行遍历
if (grid[i][j] == '@') { //如果该点为@说明为起点,赋值给sx,sy
sx = i;
sy = j;
}
else if (islower(grid[i][j])) { // 判断该点字符是否为小写,是小写则为钥匙🔑
if (!key_to_idx.count(grid[i][j])) { //判断无序map中是否有这个点
int idx = key_to_idx.size(); // 如果没有这个点,就把无序map的大小传给整数idx方便后续位运算
key_to_idx[grid[i][j]] = idx; // 把idx的值传给无序map中对应的点
}
}
}
}
queue<tuple<int, int, int>> q; // 创建一个队列q 里面存放元组tuple(x轴,y轴,存放钥匙的位运算整数)
vector<vector<vector<int>>> dist(m, vector<vector<int>>(n, vector<int>(1 << key_to_idx.size(), -1)));
// 创建一个容器它储存(移动次数)在一个容器中又储存一个容器储存int(位运算)(每一行每一列的每一个位置对应的钥匙数目)
q.emplace(sx, sy, 0); //添加初始值(起点坐标,零个钥匙)
dist[sx][sy][0] = 0; // 容器初始化(起始点为0)
while (!q.empty()) { //如果队列不为空
auto [x, y, mask] = q.front(); // 入队
q.pop(); // 出队
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][ny] != '#') {
//如果移动后的坐标没有超出边界并且不是墙
if (grid[nx][ny] == '.' || grid[nx][ny] == '@') { // 如果该点是空房间或者起点
if (dist[nx][ny][mask] == -1) { //如果移动后的容器值为 -1(说明未经过该点)
dist[nx][ny][mask] = dist[x][y][mask] + 1; // 赋值为原坐标 值 +1
q.emplace(nx, ny, mask); // 将移动后的数据添加至队列
}
}
else if (islower(grid[nx][ny])) { // 如果移动后的坐标是小写字母
int idx = key_to_idx[grid[nx][ny]]; // 把该点在无序map中存放的值 传递给idx
if (dist[nx][ny][mask | (1 << idx)] == -1) { //如果移动后的容器值为 -1
dist[nx][ny][mask | (1 << idx)] = dist[x][y][mask] + 1; // 赋值为原坐标 +1
if ((mask | (1 << idx)) == (1 << key_to_idx.size()) - 1) { // 如果最后一个钥匙被拿到
return dist[nx][ny][mask | (1 << idx)]; // 返回容器值 步数
}
q.emplace(nx, ny, mask | (1 << idx)); // 将数据入队
}
}
else { // 其他情况(墙/锁/边界)
int idx = key_to_idx[tolower(grid[nx][ny])]; // 把该点在无序map中存放的值 传递给idx
if ((mask & (1 << idx)) && dist[nx][ny][mask] == -1) { // 位与运算 并且 移动后容器值为-1
dist[nx][ny][mask] = dist[x][y][mask] + 1; // 赋值为原坐标 +1
q.emplace(nx, ny, mask); //入队
}
}
}
}
}
return -1; // 返回-1
}
private:
static constexpr int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 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}}};
//另外,定义哈希表或数组 visvis 记录当前位置以及当前拥有的钥匙的状态是否已经被访问过,如果访问过,则不需要再次访问。vis[i][j][state]vis[i][j][state] 表示当前位置为 (i, j)(i,j),当前拥有的钥匙的状态为 statestate 时,是否已经被访问过。
//我们从起点 (si, sj)(si,sj) 出发,将其加入队列 qq,并将 vis[si][sj][0]vis[si][sj][0] 置为 truetrue,表示起点位置以及拥有的钥匙的状态为 00 时已经被访问过。
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();
// 找到所有钥匙,返回当前步数
// (1 << k) - 1 为钥匙数量的二进制表示
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;
}
};