网络流24题14. 孤岛营救问题

孤岛营救问题

Description

1944 年，特种兵麦克接到国防部的命令，要求立即赶赴太平洋上的一个孤岛，营救被敌军俘虏的大兵瑞恩。瑞恩被关押在一个迷宫里，迷宫地形复杂，但幸好麦克得到了迷宫的地形图。迷宫的外形是一个长方形，其南北方向被划分为 N 行，东西方向被划分为 M 列，于是整个迷宫被划分为 N×M 个单元。每一个单元的位置可用一个有序数对(单元的行号，单元的列号)来表示。南北或东西方向相邻的 2 个单元之间可能互通，也可能有一扇锁着的门，或者是一堵不可逾越的墙。迷宫中有一些单元存放着钥匙，并且所有的门被分成 P 类，打开同一类的门的钥匙相同，不同类门的钥匙不同。
大兵瑞恩被关押在迷宫的东南角，即(N，M)单元里，并已经昏迷。迷宫只有一个入口，在西北角。也就是说，麦克可以直接进入(1，1)单元。另外，麦克从一个单元移动到另一个相邻单元的时间为 1，拿取所在单元的钥匙的时间以及用钥匙开门的时间可忽略不计。
试设计一个算法，帮助麦克以最快的方式到达瑞恩所在单元，营救大兵瑞恩。

Input

第 1 行有 3 个整数，分别表示 N,M,P 的值。第 2 行是 1
个整数 K，表示迷宫中门和墙的总数。第 I+2 行（1<=I<=K），有 5 个整数，依次为Xi1,Yi1,Xi2,Yi2,Gi：
当 Gi>=1 时，表示(Xi1,Yi1)单元与(Xi2,Yi2)单元之间有一扇第 Gi 类的门，当 Gi=0 时，表示(Xi1,Yi1)单元与(Xi2,Yi2)单元之间有一堵不可逾越的墙（其中，|Xi1-Xi2|+|Yi1-Yi2|=1，0<=Gi<=P）。
第 K+3 行是一个整数 S，表示迷宫中存放的钥匙总数。
第 K+3+J 行(1<=J<=S)，有 3 个整数，依次为 Xi1,Yi1,Qi：表示第 J 把钥匙存放在(Xi1,Yi1)单元里，并且第 J 把钥匙是用来开启第 Qi 类门的。（其中 1<=Qi<=P）。
输入数据中同一行各相邻整数之间用一个空格分隔。

Output

输出麦克营救到大兵瑞恩的最短时间的值。
如果问题无解，则输出-1。

Hint

N,M,P <= 10
K < 150

题解

网络流？？？喵喵喵？？？
分层图思想。门的数目很小，可以用二进制实现状态压缩。而对这$2^P$个状态可以对应的建$2^P$个图跑SPFA即可，当然图不用真的建出来，每次判断能不能走并在层间转移即可，具体实现看代码。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int N = 200, M = 160000, P = 1<<15, inf = 0x3f3f3f3f;
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
struct Node{
    int x, y, z;
    Node(int a, int b, int c){x = a, y = b, z = c;}
};
int n, m, p, k, s;
int idx[N][N], mp[N][N], inq[N][P], d[N][P], key[N];
int ans;
void init(){
    scanf("%d%d%d%d", &n, &m, &p, &k);
    int u, v, w;
    for(int i = 1, t = 0; i <= n; i++)
        for(int j = 1; j <= m; j++)
            idx[i][j] = ++t;
    for(int i = 1; i <= k; i++){
        scanf("%d%d", &u, &v); u = idx[u][v];
        scanf("%d%d", &v, &w); v = idx[v][w];
        scanf("%d", &w);
        if(!w) mp[u][v] = mp[v][u] = -1;
        else mp[u][v] = mp[v][u] |= 1 << w;
    }
    scanf("%d", &s);
    for(int i = 1; i <= s; i++){
        scanf("%d%d%d", &u, &v, &w);
        key[idx[u][v]] |= 1 << w;
    }
}
void work(){
    memset(d, 0x3f, sizeof(d));
    d[idx[1][1]][0] = 0;
    queue<Node> q;
    q.push(Node(1, 1, 0));
    inq[idx[1][1]][0] = 1;
    while(!q.empty()){
        Node u = q.front();
        q.pop(); int now = idx[u.x][u.y];
        inq[now][u.z] = false;
        for(int i = 0; i < 4; i++){
            int r = u.x + dx[i];
            int c = u.y + dy[i];
            if(r > 0 && r <= n && c > 0 && c <= m){
                int next = idx[r][c];
                if(mp[next][now] != -1)
                if(d[next][u.z] > d[now][u.z] + 1)
                if((u.z & mp[next][now]) == mp[next][now]){
                    d[next][u.z|key[next]] = d[next][u.z] = d[now][u.z] + 1;
                    if(!inq[next][u.z|key[next]]){
                        q.push(Node(r, c, u.z|key[next]));
                        inq[next][u.z|key[next]] = 1;
                    }
                }
            }
        }
    }
    ans = inf;
    for(int i = 0; i < (1<<p+1); i++)
        ans = min(ans, d[idx[n][m]][i]);
    if(ans == inf)
        puts("-1");
    else
        printf("%d\n", ans);
}
int main(){
    freopen("prog814.in", "r", stdin);
    freopen("prog814.out", "w", stdout);
    init();
    work();
    return 0;
}