状压 - Bfs 例题解析

---

title: 状压BFS[分层图思想]
date: 2021-06-23 14:03

& ： 两个都为 1 是为1
| ：有 1 位 1，两个都没 1 就是 0
^：异或，相同为 0，相与为 1<- 我好讨厌这个类型题，每次一碰见异或我人直接傻眼，这个符号好像克我。
<<：各二进制全部左移一位，高位丢弃，地位补 0
>>：各二进制全部右移一位，对无符号数，高位补 0，有符号数有的在符号位补 0，有的在符号位后补 0
复合赋值运算符
「
&= ： 复合赋值运算符， 将左边数值与右边先进行 & 运算后，再将结果赋值给左边。
|= ：复合赋值运算符， 将左边数值与右边先进行| 运算后，再将结果赋值给左边。
^= ： 复合赋值运算符， 将左边数值与右边先进行^ 运算后，再讲结果赋值给左边。

」

拯救大兵瑞恩

**

题解：

**
正常情况下，这道题可以直接用 DP 来解，但碍于加入了钥匙和门的元素，我们必须先找到钥匙，才可以解开特定的路线，基于此种状态下，我们将图分为 2 ^ p 层。
点 u,v,在每层图中均对应 x,y，并且 「x,y」 房间中有 i 类钥匙，所以每到达[x,y]点后，图的状态由未获得钥匙变成已得到钥匙。
所以，我们对于每把钥匙的状态有两种，获得了/未获得。
获得为 1，未获得为 0，可以用而二进制来表示，假设说有五把钥匙，初始状态就是 00000，获得第二把和第五把之后，状态就变成了我 01001. <—这里就是所谓状压（状态压缩）

#AC 代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include <set>
#include <cstdio>
#include <map>
#include <queue>
#include <stack>
#include <cmath>
#include <utility>
#include <cstring>
using namespace std;
#define pb push_back
#define LL long long
#define F(i, l, r) for(int i = l; i<= r;i++)
#define fi first
#define se second
#define PII pair<int,int>
#define IOS ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
//#pragma GCC optimize(1)
//pragma GCC optimize(2)
//#pragma GCC optimize(3,"Ofast","inline")
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
const int maxn = 20;
int n,m,p,t,tt,mp[maxn][maxn][maxn][maxn],key[maxn][maxn],vis[maxn][maxn][1<<11];
struct Node{
    int x,y,step,state;
};
bool check(int x,int y){
    if(x < 1 || x > n || y < 1 || y > m) return  false;
    return true;
}
int  bfs(){
    queue<Node>Q;
    Q.push((Node){1,1,0,key[1][1]});
    while (!Q.empty()) {
        Node u = Q.front();
        Q.pop();
        if(u.x == n && u.y == m) return u.step;
        for(int i = 0; i < 4;i++)
        {
            int x = u.x + dx[i];
            int y = u.y + dy[i];
            if(check(x, y))
            {
                if(!mp[u.x][u.y][x][y])continue;
                else if(mp[u.x][u.y][x][y] == -1 || (1 <<( mp[u.x][u.y][x][y] - 1)) & u.state)
                { // 如果 u.state 与 mp 啥的且为 1，那么说明有这个钥匙。
                    int states = u.state | key[x][y];
// states 是表示当前的图层数，如果找到钥匙了，图层数 + 1 
                    if(!vis[x][y][states])
                    {
                        Q.push((Node){x,y,u.step + 1,states});
                        vis[x][y][states] = 1;
                    }
                }
            }
        }
    }
    return -1;
}
int main(){
    IOS;
    cin >> n >> m >> p;
    cin >> t;
    memset(mp, -1, sizeof(mp));
    for(int i = 0 ; i < t;i++)
    {
        int x1,y1,x2,y2,g;
        cin >> x1 >> y1 >> x2 >> y2 >> g;
        mp[x1][y1][x2][y2] = mp[x2][y2][x1][y1] = g;
    }
    cin >> tt;
    for(int i = 0; i < tt;i++)
    {
        int a,b,c;
        cin >> a >> b >> c;
        key[a][b] |= (1 << (c - 1));
}
    cout << bfs();
}

状压代码详解：
> * key[a][b] |= (1 << (c - 1));*
一个房间并不是只有一把钥匙，所以在这里 通过 key[a][b] |= (1 << (c - 1)) 可以将有钥匙的种类记录下来
比方说现在没有钥匙，我们在[x][y] 房间里找到了 3 号钥匙，那么现在 key[x][y] |= (1 << (3 - 1))
就是 0000 | 0100 = 0100 。呐，第三位就取得了钥匙，变为 1 。
假设过了一会儿我们又在[x][y]房间找到了 4 号钥匙，那么现在 key[x][y] |= (1 << (4 - 1))
就是 0100 | 1000 = 1100 ，代表现在第三位第四位都找到了钥匙。