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] 
每个钥匙都对应一个 不同 的字母
每个钥匙正好打开一个对应的锁

来源：力扣(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;
    }
};