864. Shortest Path to Get All Keys

问题：

给定一个迷宫数组：

• @：起点
• #：墙壁
• a~f：key
• A～F：lock

从起点开始走，遇到key，可以拾得，用于开启后续遇到的lock，（若遇到lock前没有拾得对应key，那么无法通过）

墙壁也无法通过。求要获得所有的key，最少走的步数。

不可能获得所有的key的话，返回-1。

Example 1:
Input: ["@.a.#","###.#","b.A.B"]
Output: 8

Example 2:
Input: ["@..aA","..B#.","....b"]
Output: 6
 
Note:
1 <= grid.length <= 30
1 <= grid[0].length <= 30
grid[i][j] contains only '.', '#', '@', 'a'-'f' and 'A'-'F'
The number of keys is in [1, 6].  Each key has a different letter and opens exactly one lock.

　　

解法：BFS

状态：state

• 坐标：(i,j)
• 当前拾得key的状态：key_map: bit标记法 

class state {
public:
    int i;
    int j;
    int key;
    state(){}
    state(int i_1, int j_1, int key_1) {
        i = i_1;
        j = j_1;
        key = key_1;
    }
    string to_string(){//for visited check
        return std::to_string(i) + " " + std::to_string(j) + " " + std::to_string(key);
    }
};

首先，统计key的个数，得到目标key状态target_k，没找到一个key：

                else if(grid[i][j]>='a' && grid[i][j]<='f') {
                    target_k|=(1<<(grid[i][j]-'a'));
                    //cout<<target_k<<endl;
                }

同时找到起点，加入queue和visited中。

                if(grid[i][j]=='@') {//Start node
                    state start(i,j,0);
                    q.push(start);
                    visited.insert(start.to_string());
                } 

然后遍历横展开queue：

每一层代表一步，step++

• 如果当前node的keymap==target_k，则返回step
• 否则找下一个位置：
  • 上下左右，四个方向：排除以下两种情况：
    • 遇到# | | 超出数组边界 ，continue
    • 遇到lock，同时没有得到对应key，continue
  • 遇到key：更新keymap
  • 将新位置加入queue和visited中。

代码参考：

class state {
public:
    int i;
    int j;
    int key;
    state(){}
    state(int i_1, int j_1, int key_1) {
        i = i_1;
        j = j_1;
        key = key_1;
    }
    string to_string(){//for visited check
        return std::to_string(i) + " " + std::to_string(j) + " " + std::to_string(key);
    }
};
class Solution {
public:
    int n,m;
    vector<int> dir = {1,0,-1,0,1};
    //state:(i,j) getkey_map
    int shortestPathAllKeys(vector<string>& grid) {
        n=grid.size();
        m=grid[0].size();
        queue<state> q;
        unordered_set<string> visited;
        int target_k=0;
        for(int i=0; i<n; i++) {
            for(int j=0; j<m; j++) {
                if(grid[i][j]=='@') {//Start node
                    state start(i,j,0);
                    q.push(start);
                    visited.insert(start.to_string());
                } else if(grid[i][j]>='a' && grid[i][j]<='f') {
                    target_k|=(1<<(grid[i][j]-'a'));
                    //cout<<target_k<<endl;
                }
            }
        }
        if(q.size()>1) return -1;
        state cur, next;
        int step = 0;
        char next_c;
        while(!q.empty()) {
            int sz = q.size();
            for(int i=0; i<sz; i++) {
                cur = q.front();
                q.pop();
                //cout<<"step:"<<step<<" pop:"<<cur.to_string()<<endl;
                if(cur.key==target_k) return step;
                for(int j=1; j<5; j++) {
                    next = cur;
                    next.i += dir[j-1];
                    next.j += dir[j];
                    if(next.i<0 || next.j<0 || next.i>=n || next.j>=m) continue;
                    next_c = grid[next.i][next.j];
                    //cout<<"    next_i:"<<next.i<<" next_j:"<<next.j<<" next_c:"<<next_c<<" next_key:"<<next.key<<endl;
                    if(next_c=='#') continue;
                    //lock://not have this key
                    if(next_c>='A' && next_c<='F' && ((next.key>>(next_c-'A'))&1)==0) continue;
                    //cout<<"(next.key>>(next_c-'A'))&1==0:"<< ((next.key>>(next_c-'A'))&1)==0 ;
                    if(next_c>='a' && next_c<='f') {//take this key
                        next.key |= (1<<(next_c-'a'));
                    }
                    if(visited.insert(next.to_string()).second) {
                        //cout<<"    push next:"<<next.to_string()<<endl;
                        q.push(next);
                    }
                }
            }
            step++;
        }
        return -1;
    }
};

⚠️ 注意：两层if嵌套的时候，内层continue，无法使得外层也continue。