拯救大兵瑞恩 —— 最短路扩展 DP + BFS

拯救大兵瑞恩

题面

思路

假设没有钥匙和门的概念，这题就是最基础的迷宫问题(从左上到右下一个BFS即可)；

现在引入了钥匙和门的概念；

假设我们当前在$(x,y)$，要前往周围的四个格子，但是我们只用$(x,y)$是无法表示我们手上有几把钥匙的；

看到钥匙的种类最多为$10$，考虑状压来表示；

我们用$dist(x,y,s)$表示从点$(1,1)$出发到点$(x,y)$且拥有的钥匙集合为$s$的所有路线中的最小值；

那么问题就转化成了求$dist(n,m,s_{n,m})$的问题了；

其中$s_{n,m}$的取值是无所谓的，我们只关心能到达终点就行；

---

接着考虑状态转移；

为了表示方便，我们将二维的坐标压缩成一维的即可；

也就是代码中的

int get(int x,int y){
    return (x - 1) * m + y;
}

假设我们当前的点为$u$，转移过去的点为$v$；

那么自然有$dist(v,s_v)=dist(u,s_u)+1$

因为拿起钥匙是不需要消耗时间的，且钥匙越多显然越好；

因此有$s_v=s_u|点v放置的钥匙$

---

接着想想代码怎么写，因为$DP$我们一般是写成循环的形式；

但是这道题中，状态转移的顺序不是一个拓扑序，是会兜圈子的；

比如样例中的这四个格子；

因此我们考虑用最短路来解决这个DP问题；

我们发现，任意状态之间的转移，边权只会是$1$，因此跑一个BFS即可；

Code

#include <iostream>
#include <cstring>
#include <cstdio>
#include <set>
#include <utility>
#include <queue>
#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 15,E = 400,M = N*N;

int n,m,p,k;

typedef pair<int,int> pii;

//二维坐标映射到一维
int get(int x,int y){
    return (x - 1) * m + y;
}
set<pii> st;
struct Edge{
    int to,val,next;
}e[E];
int head[M],vis[M][1 << 10],tot;
int pkey[M];//get(x,y)含有的钥匙
void add(int u,int v,int w){
    ++tot;
    e[tot].val = w;
    e[tot].to = v;
    e[tot].next = head[u];
    head[u] = tot;
}
int dx[] = {1,-1,0,0};
int dy[] = {0,0,1,-1};
int dist[M][1 << 10];
int bfs(){
    memset(dist,0x3f,sizeof dist);
    queue<pii> que;//(u,state);
    int start = get(1,1);
    //如果起点有钥匙 全部带上
    que.push({start,pkey[start]});
    dist[start][pkey[start]] = 0;
    vis[start][pkey[start]] = 1;
    while(!que.empty()){
        auto u = que.front();
        que.pop();
        if(u.first == get(n,m)) return dist[u.first][u.second];
        for(int i=head[u.first];i;i=e[i].next){
            int to = e[i].to;
            //如果有门 但我们没有钥匙 直接滚蛋
            int need = e[i].val;
            if(need && !(u.second >> (need - 1) & 1)) continue;
            //如果我们有钥匙 或者 没有门
            //拿上当前点的钥匙 无论有无
            int now_key = u.second | pkey[to];
            if(!vis[to][now_key]){
                vis[to][now_key] = 1;
                dist[to][now_key] = dist[u.first][u.second] + 1;
                que.push({to,now_key});
            }
        }
    }
    return -1;
}
void solve(){
    cin >> n >> m >> p >> k;
    while(k--){
        int x1,y1,x2,y2,type;
        cin >> x1 >> y1 >> x2 >> y2 >> type;
        //st中存的是两个点之间存在特殊的边(墙或门)
        int u = get(x1,y1),v = get(x2,y2);
        st.insert({u,v});
        st.insert({v,u});
        if(type){
            add(u,v,type),add(v,u,type);
        }
    }
    //建立普通边
    for(int i=1;i<=n;++i){
        for(int j=1;j<=m;++j){
            for(int k=0;k<4;++k){
                int x = i + dx[k];
                int y = j + dy[k];
                if(x < 1 || x > n || y < 1 || y > m) continue;
                int u = get(i,j);
                int v = get(x,y);
                if(!st.count({u,v}))
                    add(u,v,0);
            }
        }
    }
    int keys;
    cin >> keys;
    while(keys--){
        int x,y,key;//key的编号从1开始
        cin >> x >> y >> key;
        //我们二进制位表示从0开始
        pkey[get(x,y)] |= 1 << (key - 1);
    }
    cout << bfs() << '\n';
}

signed main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int t = 1;
   // cin >> t;
    while(t--)
        solve();
    return 0;
}