1131. 拯救大兵瑞恩

1944 年，特种兵麦克接到国防部的命令，要求立即赶赴太平洋上的一个孤岛，营救被敌军俘虏的大兵瑞恩。

瑞恩被关押在一个迷宫里，迷宫地形复杂，但幸好麦克得到了迷宫的地形图。

迷宫的外形是一个长方形，其南北方向被划分为 N 行，东西方向被划分为 M 列， 于是整个迷宫被划分为 N×M 个单元。

每一个单元的位置可用一个有序数对 (单元的行号, 单元的列号) 来表示。

南北或东西方向相邻的 2 个单元之间可能互通，也可能有一扇锁着的门，或者是一堵不可逾越的墙。

注意： 门可以从两个方向穿过，即可以看成一条无向边。

迷宫中有一些单元存放着钥匙，同一个单元可能存放 多把钥匙，并且所有的门被分成 P 类，打开同一类的门的钥匙相同，不同类门的钥匙不同。

大兵瑞恩被关押在迷宫的东南角，即 (N,M) 单元里，并已经昏迷。

迷宫只有一个入口，在西北角。

也就是说，麦克可以直接进入 (1,1) 单元。

另外，麦克从一个单元移动到另一个相邻单元的时间为 1，拿取所在单元的钥匙的时间以及用钥匙开门的时间可忽略不计。

试设计一个算法，帮助麦克以最快的方式到达瑞恩所在单元，营救大兵瑞恩。

输入格式

第一行有三个整数,分别表示 N,M,P 的值。

第二行是一个整数 k，表示迷宫中门和墙的总数。

接下来 k 行，每行包含五个整数，Xi1,Yi1,Xi2,Yi2,Gi：当 Gi≥1 时，表示 (Xi1,Yi1) 单元与 (Xi2,Yi2) 单元之间有一扇第 Gi 类的门，当 Gi=0 时，表示 (Xi1,Yi1) 单元与 (Xi2,Yi2) 单元之间有一面不可逾越的墙。

接下来一行，包含一个整数 S，表示迷宫中存放的钥匙的总数。

接下来 S 行，每行包含三个整数 Xi1,Yi1,Qi，表示 (Xi1,Yi1) 单元里存在一个能开启第 Qi 类门的钥匙。

输出格式

输出麦克营救到大兵瑞恩的最短时间。

如果问题无解，则输出 -1。

数据范围

|Xi1−Xi2|+|Yi1−Yi2|=1,
0≤Gi≤P,
1≤Qi≤P,
1≤N,M,P≤10,
1≤k≤150

输入样例：

4 4 9
9
1 2 1 3 2
1 2 2 2 0
2 1 2 2 0
2 1 3 1 0 
2 3 3 3 0
2 4 3 4 1
3 2 3 3 0
3 3 4 3 0
4 3 4 4 0
2
2 1 2 
4 2 1

输出样例：

14

样例解释：

迷宫如下所示：

思路：

/*
将迷宫中的二维坐标压缩成一维数组方便枚举，即nn行mm列的迷宫中点(x,y)的下标为t=(x−1)∗n+y
设dist[t][state]表示所有从起点走到tt这个格子，且当前已经拥有的钥匙是state的所有路线的集合中的最短距离
用一个10位的二进制数state存储每一类🔑的存放情况
初始时，对于没有🔑的单元，只有一种状态dist[t][0]；对于包含🔑的单元，有两种状态dist[t][0]和dist[t][state]（因为只要有钥匙一定是全部带着，否则有可能走回头路）
状态转移的方式分以下2种情况：
拿起所有钥匙（花费时间0）：dist[t][state]=min(dist[t][state],dist[t][0])
向四周移动，只有以下2种情况能走（花费时间1）：dist[t1][state]=min(dist[t1][state],dist[t2][state]+1)
（1）没有门和墙
（2）有门，且有匹配的钥匙
状态转移过程中花费时间只有0或者1，因此考虑使用双端队列BFS
*/

代码：

// 拆点
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;

const int N = 11, M = 360, P = 1 << 10;
int n, m, k, p;
int h[N * N], e[M], ne[M], w[M], idx;
int g[N][N], key[N * N];
int dist[N * N][P];
bool st[N * N][P];
int nex[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
set<PII> edges;

void add(int a, int b, int c)
{
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx++;
}

void build()
{
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            for (int k = 0; k < 4; k++)
            {
                int dx = i + nex[k][0], dy = j + nex[k][1];
                if (dx < 1 || dx > n || dy < 1 || dy > m)
                    continue;
                int a = g[i][j], b = g[dx][dy];
                if (!edges.count({a, b})) // 不在集合中 则可以随意走
                    add(a, b, 0);
            }
        }
    }
}

int bfs()
{
    memset(dist, 0x3f, sizeof(dist));
    dist[1][0] = 0;

    deque<PII> qu;
    qu.push_back({1, 0});

    while (qu.size())
    {
        PII t = qu.front();
        qu.pop_front();

        int ver = t.first, ori = t.second;

        if (st[ver][ori])
            continue;
        st[ver][ori] = 1;

        if (ver == n * m)
            return dist[ver][ori];

        if (key[ver]) // 捡起钥匙 放入堆中
        {
            int state = ori | key[ver];
            if (dist[ver][state] > dist[ver][ori])
            {
                dist[ver][state] = dist[ver][ori];
                qu.push_front({ver, state});
            }
        }

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (!st[j][ori]) // 未捡起的状态更新其他点
            {
                if (w[i] && !(ori >> (w[i] - 1) & 1)) // 如果有锁且没有钥匙
                    continue;
                if (dist[j][ori] > dist[ver][ori] + 1)
                {
                    dist[j][ori] = dist[ver][ori] + 1;
                    qu.push_back({j, ori});
                }
            }
        }
    }

    return -1;
}
int main()
{
    cin >> n >> m >> p >> k;
    for (int i = 1, t = 1; i <= n; i++) // 二维化一维
        for (int j = 1; j <= m; j++, t++)
            g[i][j] = t;

    memset(h, -1, sizeof(h));

    while (k--)
    {
        int x1, y1, x2, y2, c;
        cin >> x1 >> y1 >> x2 >> y2 >> c;
        int a = g[x1][y1], b = g[x2][y2];

        edges.insert({a, b}), edges.insert({b, a});
        if (c)
            add(a, b, c), add(b, a, c);
    }

    build();

    int s;
    cin >> s;
    while (s--) // 状态压缩钥匙
    {
        int x, y, c;
        cin >> x >> y >> c;
        key[g[x][y]] |= 1 << c - 1;
    }

    cout << bfs() << endl;

    return 0;
}