Leetcode刷题笔记 LCP 13. 寻宝

题目
我们得到了一副藏宝图，藏宝图显示，在一个迷宫中存在着未被世人发现的宝藏。

迷宫是一个二维矩阵，用一个字符串数组表示。它标识了唯一的入口（用 ‘S’ 表示），和唯一的宝藏地点（用 ‘T’ 表示）。但是，宝藏被一些隐蔽的机关保护了起来。在地图上有若干个机关点（用 ‘M’ 表示），只有所有机关均被触发，才可以拿到宝藏。

要保持机关的触发，需要把一个重石放在上面。迷宫中有若干个石堆（用 ‘O’ 表示），每个石堆都有无限个足够触发机关的重石。但是由于石头太重，我们一次只能搬一个石头到指定地点。

迷宫中同样有一些墙壁（用 ‘#’ 表示），我们不能走入墙壁。剩余的都是可随意通行的点（用 ‘.’ 表示）。石堆、机关、起点和终点（无论是否能拿到宝藏）也是可以通行的。

我们每步可以选择向上/向下/向左/向右移动一格，并且不能移出迷宫。搬起石头和放下石头不算步数。那么，从起点开始，我们最少需要多少步才能最后拿到宝藏呢？如果无法拿到宝藏，返回 -1 。

示例1
输入：
[“S#O”, “M…”, “M.T”]
输出：
16
解释：
最优路线为： S->O, cost = 4, 去搬石头 O->第二行的M, cost = 3, M机关触发 第二行的M->O, cost = 3, 我们需要继续回去 O 搬石头。 O->第三行的M, cost = 4, 此时所有机关均触发 第三行的M->T, cost = 2，去T点拿宝藏。 总步数为16。

示例1
输入：
[“S#O”, “M.#”, “M.T”]
输出：
-1
解释：
我们无法搬到石头触发机关

示例1
输入：
[“S#O”, “M.T”, “M…”]
输出：
17
解释：
注意终点也是可以通行的。

限制：
1 <= maze.length <= 100
1 <= maze[i].length <= 100
maze[i].length == maze[j].length
S 和 T 有且只有一个
0 <= M的数量 <= 16
0 <= O的数量 <= 40，题目保证当迷宫中存在 M 时，一定存在至少一个 O 。

解法

1. 经过简单的模拟，我们可以知道走法分为4种
   1. S到O 捡石头
   2. O到M 用石头触发机关
   3. M到O 到下个地方捡石头
   4. M到T 所有机关触发，走出迷宫
2. 由于这些点都不会移动，我们要做大量的预处理工作，计算几个特殊点之间的距离（BFS）
3. 需要计算的距离
   1. 一开始我们都是从S点出发，需要走到一个O点拿石头，再到M点才能让这个点触发。对于M来说，寻找合适的O点，使S到M的距离最短。
   2. 当到达M点时，我们需要再走到一个O点拿石头，再去M‘点，而对于M’来说，寻找合适的O点，使M到M‘的距离最短，用d(i,j)表示第i个M到第j个M经过一个O点的最短距离
   3. 计算所有M点到T点的距离
4. M的触发顺序不同会导致行走的路径不同，用16位的二进制mask表示是否已经走到M点
   1. 这个二进制数的第i位为1，表示第i个M已经触发，为0表示第i个M还未被触发
   2. 当n = 16，mask= 0000 1100 0001 0001 已经走的点时M1，M5，M11，M12,这些点合称为触发了的集合
5. 定义dp(mask,i)表示当前在第i个M处，触发状态为mask的最小步数
   1. 动态转移方程 ：dp(mask,i) = min(dp(mask xor 2^i,j) + d(j,i)) j!=i,j属于触发了的集合
      1. mask xor 2^i 表示从集合中去除第i个M，在第i个M没有触发的情况下
      2. 现在的状态是：mask记录之前所有M点的情况（包括触发和不触发），现已到第i个M点（触发了）
      3. 这个状况是怎么转移过来的呢？在所有已经触发的集合中，找到第j个M点，能够使在j点触发 + d(j,i)的距离最小，
   2. 循环实现
      dp(mask|2^j,j) = min(dp(mask,j)+d(j,i))
6. 注意边界

代码

#include <stdio.h>
#include <vector>
#include <iostream>
#include <queue>
using namespace std;
class Solution {
public:
    //四个方向搜索
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int n, m;
    //判断边界
    bool inBound(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < m;
    }
    //从这个点开始，与其他点的距离，维度（n，m）
    vector<vector<int>> bfs(int x, int y, vector<string>& maze) {
        vector<vector<int>> ret(n, vector<int>(m, -1));
        //标记这个点开始要走了
        ret[x][y] = 0;
        queue<pair<int, int>> Q;
        Q.push({x, y});
        while (!Q.empty()) {
            pair<int,int> p = Q.front();
            Q.pop();
            int x = p.first, y = p.second;
            for (int k = 0; k < 4; k++) {
                int nx = x + dx[k], ny = y + dy[k];//四个方向开始寻找
                //不能走出边界，不能到障碍物，还没有被走过
                if (inBound(nx, ny) && maze[nx][ny] != '#' && ret[nx][ny] == -1) {
                    ret[nx][ny] = ret[x][y] + 1;
                    Q.push({nx, ny});
                }
            }
        }
        return ret;
    }
    
    int minimalSteps(vector<string>& maze) {
        n = maze.size(), m = maze[0].size();
        vector<pair<int, int>> buttons, stones;
        int sx, sy, tx, ty;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (maze[i][j] == 'M') { //机关
                    buttons.push_back({i, j});
                }
                if (maze[i][j] == 'O') { //石头
                    stones.push_back({i, j});
                }
                if (maze[i][j] == 'S') {//起点
                    sx = i, sy = j;
                }
                if (maze[i][j] == 'T') {//终点
                    tx = i, ty = j;
                }
            }
        }
        int nb = buttons.size();
        int ns = stones.size();
        //计算从S出发到各个点的距离
        vector<vector<int>> start_dist = bfs(sx, sy, maze);
        
        // 边界情况：没有机关，从S直接到T
        if (nb == 0) {
            return start_dist[tx][ty];
        }
        // 从某个机关到其他机关 / 起点与终点的最短距离，已经过O点。
        vector<vector<int>> dist(nb, vector<int>(nb + 2, -1));
        vector<vector<vector<int>>> dd(nb);
        for (int i = 0; i < nb; i++) {
            //第i个机关，与其他点的距离，d的维度为(n,m)
            vector<vector<int>> d = bfs(buttons[i].first, buttons[i].second, maze);
            //每个机关都有一个维度为(n,m)的距离数组，dd的维度为(nb,n,m)
            dd[i] = d;
            //对于已经触发的第i个机关，到终点的距离
            dist[i][nb + 1] = d[tx][ty];
        }
        for (int i = 0; i < nb; i++) {
            
            //对于第i个机关，找到该M从S->O->M最近的距离
            //1.一开始我们都是从S点出发，需要走到一个O点拿石头，再到M点才能让这个点触发。对于M来说，寻找合适的O点，使S到M的距离最短。
            int tmp = -1;
            for (int k = 0; k < ns; k++) { //ns个石头区
                int mid_x = stones[k].first, mid_y = stones[k].second; //第k个石头的下标
                //第i个机关能到达第k个石头区，且从S能到达第k个石头区
                if (dd[i][mid_x][mid_y] != -1 && start_dist[mid_x][mid_y] != -1) {
                    if (tmp == -1 || tmp > dd[i][mid_x][mid_y] + start_dist[mid_x][mid_y]) {
                        //更新距离为 第i个机关到第k个石头区的距离 + S到第k个石头的距离
                        tmp = dd[i][mid_x][mid_y] + start_dist[mid_x][mid_y];
                    }
                }
            }
            dist[i][nb] = tmp;//从第i个机关与起点最短距离，已经过O点，或者说从起点出发，触发第i个机关的最短距离。
            
            //对于第i个机关，找到该M从M->O->M’最近的距离
            //2.当到达M点时，我们需要再走到一个O点拿石头，再去M‘点，而对于M’来说，寻找合适的O点，使M到M‘的距离最短，
            for (int j = i + 1; j < nb; j++) { //M' != M
                int mn = -1;
                for (int k = 0; k < ns; k++) {
                    int mid_x = stones[k].first, mid_y = stones[k].second;
                    //第i个机关能到达第k个石头区，且第j个机关也能到达第k个石头区
                    if (dd[i][mid_x][mid_y] != -1 && dd[j][mid_x][mid_y] != -1) {
                        if (mn == -1 || mn > dd[i][mid_x][mid_y] + dd[j][mid_x][mid_y]) {
                            //更新距离为第i个机关到第k个石头区的距离 + 第j个机关到第k个石头区的距离
                            mn = dd[i][mid_x][mid_y] + dd[j][mid_x][mid_y];
                        }
                    }
                }
                dist[i][j] = mn;//i到j和j到i距离相同
                dist[j][i] = mn;
            }
        }
        
        // 无法达成的情形，有一个机关不能从S到达，或者不能到达终点
        for (int i = 0; i < nb; i++) {
            if (dist[i][nb] == -1 || dist[i][nb + 1] == -1) return -1;
        }
        
        // 初始化dp，-1为未到达
        vector<vector<int>> dp(1 << nb, vector<int>(nb, -1)); //nb为机关个数
        //1.S->O->M
        for (int i = 0; i < nb; i++) {
            //1 << i代表只有第i个M点被触发时所需要的距离
            dp[1 << i][i] = dist[i][nb];
        }
        
        //2.M->O->M'
        for (int mask = 1; mask < (1 << nb); mask++) {
            for (int i = 0; i < nb; i++) {
                // 当前 dp 是合法的，并且从第i个节点开始
                if (mask & (1 << i)) {
                    for (int j = 0; j < nb; j++) {
                        // 寻找j，并且j不在 mask 里
                        if (!(mask & (1 << j))) {
                            //把j加入mask，并更新
                            int next = mask | (1 << j);
                            if (dp[next][j] == -1 || dp[next][j] > dp[mask][i] + dist[i][j]) {
                                dp[next][j] = dp[mask][i] + dist[i][j];
                            }
                        }
                    }
                }
            }
        }
        //3.M->T
        int ret = -1;
        int final_mask = (1 << nb) - 1;//最后的情况
        //寻找所有机关都被触发时，且停留在第i个机关上的距离，和从第i个机关到终点距离最短的
        for (int i = 0; i < nb; i++) {
            if (ret == -1 || ret > dp[final_mask][i] + dist[i][nb + 1]) {
                ret = dp[final_mask][i] + dist[i][nb + 1];
            }
        }
        
        return ret;
    }
};
int main()
{
    vector<string> maze;
    maze[0] = "S#O";
    maze[1] = "M..";
    maze[2] = "M.T";
    Solution s;
    cout<<s.minimalSteps(maze);
}

今天也是爱zz的一天哦！