LeetCode-获取所有钥匙的最短路径(BFS+状态压缩)

NCSTOJ-获取所有钥匙的最短路径

LeetCode-864. 获取所有钥匙的最短路径

Description

给定一个二维网格 grid。

“.” 代表一个空房间， “#” 代表一堵墙， “@” 是起点，（“a”, “b”, …）代表钥匙，（“A”, “B”, …）代表锁。

我们从起点开始出发，一次移动是指向四个基本方向之一行走一个单位空间。我们不能在网格外面行走，也无法穿过一堵墙。

如果途经一个钥匙，我们就把它捡起来。除非我们手里有对应的钥匙，否则无法通过锁。

假设 K 为钥匙/锁的个数，且满足 1 <= K <= 6，字母表中的前 K 个字母在网格中都有自己对应的一个小写和一个大写字母。

换言之，每个锁有唯一对应的钥匙，每个钥匙也有唯一对应的锁。

另外，代表钥匙和锁的字母互为大小写并按字母顺序排列。

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

Input

整数n, m，代表grid的行、列 （1 ≤ n,m ≤ 30）

以下为n*m的矩阵

Output

获取所有钥匙所需要的移动的最少次数

Sample Input

3 5
@.a.#
###.#
b.A.B

Sample Output

8

思路

最近在看状态压缩，但还是一知半解，做这道题前听说会用到状压，所以做的时候总在想怎么去状压，结果搞了两个晚上才搞出来。第一天晚上当成普通的bfs写的，结果提交时发现有了反例，因此这么写行不通。这道题在bfs上又多加了个状态，记得曾经写过一道题，poj4115鸣人与佐助，那道题也加了个状态，手中查克拉的数量。所以需要多定义个变量来保存状态。接着有着这个思路，又在自己写的bfs基础上加了个状态保存，用一个三维数组来保存每种状态。可后来又发现，还是有点不同的，这道题是一把钥匙配一把锁，而那道题只要手中有查克拉，就能打到一个手下。所以这道题还要保存下当前手中有哪些钥匙，那要不就用一个book数组来保存当前手中的钥匙吧，但这种全局数组还是不能满足当前手中的钥匙量，也就是说bfs沿着两条不同的路走，分别搜索钥匙，搜到就存到数组中，但这样就是共享一个数组了，分不清沿着这条路走，其中一把钥匙是在这条路上还是不在。所以这回就想到了最近学的状压了，哈哈，刚好，位进制可以表示一种状态，每走一步就有一个状态，这个状态是独立的，只归这一步所有。与其他的不受影响。
这样初始化状态，题目中说最多6把钥匙，数据量也不大。选取1<<k-1为最终状态量，记0表示没有，1表示有，那11111表示所有钥匙都找到了，00000就是初始状态。并且这种状态表示法，还能取出相应位置上的状态，比如走到一把锁面前，想知道目前是否有匹配的钥匙，那就取出所对应的钥匙位。当找到一把钥匙了，那就把该钥匙位变为1，直到所有钥匙位都变为1时，所有的钥匙就都找到了。

LeetCode

struct Step
{
    int x;
    int y;
    int ck; //目前手中钥匙的状态
    Step(int x,int y,int ck):x(x),y(y),ck(ck){}
};
class Solution {
public:
    queue<Step> que;
    bool vis[35][35][1<<7]={false}; //标记当前状态是否被拓展
    const int dis[4][2]={0,1,1,0,0,-1,-1,0};
    int shortestPathAllKeys(vector<string>& grid) {

        int len1=grid.size();
        int len2=grid[0].length();
        int k=0; //记录钥匙的数量
        for(int i=0;i<len1;i++)
        {
            for(int j=0;j<len2;j++)
            {
                if(grid[i][j]>='a'&&grid[i][j]<='z') k++;
                if(grid[i][j]=='@')
                {
                    que.push(Step(i,j,0));
                    vis[i][j][0]=true;
                }
            }
        }
        int steps=0;
        while(!que.empty())
        {
            int l=que.size();
            while(l--)
            {
                Step u=que.front();

                que.pop();
                for(int i=0;i<4;i++)
                {
                    int dx=u.x+dis[i][0];
                    int dy=u.y+dis[i][1];
                    int x=u.ck; //取出当前状态
                    
                    if(dx>=0&&dx<len1&&dy>=0&&dy<len2)
                    {
                        char ch=grid[dx][dy];
                        if(ch=='#'||vis[dx][dy][x]) continue;
                        if(ch>='a'&&ch<='z')
                        {
                            x=x|(1<<(ch-'a')); //将该位变为1
                            if(x==((1<<k)-1))
                            {
                                return steps+1;
                            }
                        }
                        if(ch>='A'&&ch<='Z')
                        {
                            if(!(x>>(ch-'A')&1)) //判断当前位是否是1
                            {
                                continue;
                            }
                        }
                        vis[dx][dy][x]=true;
                        que.push(Step(dx,dy,x));
                    }
                }
            }
            steps++; //步数加1
        }
        return -1;
    }
};

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
struct Node
{
    int x;
    int y;
    int ck; //身上目前拥有的钥匙状态
    int steps; //步数
    Node(int x,int y,int ck,int s):x(x),y(y),ck(ck),steps(s){}
};
int n,m; // n行m列
vector<vector<char> > vec;
bool usr[35][35][1<<7]={false}; //表示在i,j处身上有的钥匙，该状态是否被拓展
int k; //记录钥匙的个数
queue<Node> que;
//int book[7]; //标记手中有的钥匙
const int dis[4][2]={0,1,1,0,0,-1,-1,0};
int main()
{
     // freopen("test.txt","r",stdin);
    cin>>n>>m;
    vec.resize(n+1,vector<char>(m+1));
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cin>>vec[i][j];
            if(vec[i][j]>='a'&&vec[i][j]<='z') k++;
            if(vec[i][j]=='@') 
            {
                que.push(Node(i,j,0,0));
                usr[i][j][0]=true;
                vec[i][j]='.'; //将起点变为道路，方便后面遍历，在这坑了好长时间，后来走了一遍发现起点这有问题
            }
        }
    }
    bool flag=false;
    while(!que.empty())
    {
        Node p=que.front();
        que.pop();
        if(flag) break;
        for(int i=0;i<4;i++)
        {
            int dx=p.x+dis[i][0];
            int dy=p.y+dis[i][1];
            if(dx>=0&&dx<n&&dy>=0&&dy<m)
            {
                char ch=vec[dx][dy];
                int x=p.ck;
                if(vec[dx][dy]=='#'||usr[dx][dy][x]) continue;
                if(vec[dx][dy]=='.')
                {
                    que.push(Node(dx,dy,x,p.steps+1));
                    usr[dx][dy][x]=true;
                }
                if(vec[dx][dy]>='a'&&vec[dx][dy]<='z')
                {
                    x=x|(1<<(ch-'a')); //将该位变为1
                    if(x==((1<<k)-1))
                    {
                        cout<<p.steps+1<<endl;
                        flag=true;
                        break;
                    }
                    que.push(Node(dx,dy,x,p.steps+1));
                    usr[dx][dy][x]=true;
                    
                }
                if(vec[dx][dy]>='A'&&vec[dx][dy]<='Z')
                {
                    int j=(ch+32-'a');
                    if(x>>j&1) //表示手中有匹配的钥匙
                    {
                        que.push(Node(dx,dy,x,p.steps+1));
                        usr[dx][dy][x]=true;
                    }
                }
            }
        }
    }
    if(flag==false) cout<<-1<<endl;
    return 0;
}

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <string>
#include <unordered_set>
#include <queue>
using namespace std;
struct Step
{
    int x;
    int y;
    int ck; //目前手中钥匙的状态
    Step(int x, int y, int ck) : x(x), y(y), ck(ck) {}
};
class Solution
{
public:
    queue<Step> que;
    bool vis[35][35][1 << 7] = {false}; //标记当前状态是否被拓展
    const int dis[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};
    int shortestPathAllKeys(vector<string> &grid)
    {
        int len1 = grid.size();
        int len2 = grid[0].length();
        int k = 0; //记录钥匙的数量
        for (int i = 0; i < len1; i++)
        {
            for (int j = 0; j < len2; j++)
            {
                if (grid[i][j] >= 'a' && grid[i][j] <= 'z')
                    k++;
                if (grid[i][j] == '@')
                {
                    que.push(Step(i, j, 0));
                    vis[i][j][0] = true;
                }
            }
        }
        int steps = 0;
        while (!que.empty())
        {
            int l = que.size();
            while (l--)
            {
                Step u = que.front();
                que.pop();
                for (int i = 0; i < 4; i++)
                {
                    int dx = u.x + dis[i][0];
                    int dy = u.y + dis[i][1];
                    int x = u.ck; //取出当前状态
                    if (dx >= 0 && dx < len1 && dy >= 0 && dy < len2)
                    {
                        char ch = grid[dx][dy];
                        if (ch == '#' || vis[dx][dy][x])
                            continue;
                        if (ch >= 'a' && ch <= 'z')
                        {
                            x = x | (1 << (ch - 'a')); //将该位变为1
                            if (x == ((1 << k) - 1))
                            {
                                return steps + 1;
                            }
                        }
                        if (ch >= 'A' && ch <= 'Z' && !(x >> (ch - 'A') & 1))
                        {
                            continue;
                        }
                        vis[dx][dy][x] = true;
                        que.push(Step(dx, dy, x));
                    }
                }
            }
            steps++; //步数加1
        }
        return -1;
    }
};
vector<string> vec;
int n, m;
int main()
{
    //freopen("test.txt","r",stdin);
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        string ss;
        cin >> ss;
        vec.push_back(ss);
    }
    Solution s;
    cout << s.shortestPathAllKeys(vec) << endl;
    return 0;
}

#算法模版/状态压缩