力扣杯 LCP 13.寻宝（点击查看题目)
力扣leetcode-cn.com题目描述
我们得到了一副藏宝图，藏宝图显示，在一个迷宫中存在着未被世人发现的宝藏。
迷宫是一个二维矩阵，用一个字符串数组表示。它标识了唯一的入口（用 '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。
示例 2：
输入：["S#O", "M.#", "M.T"]
输出：-1
解释：我们无法搬到石头触发机关
示例 3：
输入：["S#O", "M.T", "M.."]
输出：17
解释：注意终点也是可以通行的。
限制：
1 <= maze.length <= 1001 <= maze[i].length <= 100maze[i].length == maze[j].length- S 和 T 有且只有一个
- 0 <= M 的数量 <= 16
- 0 <= O 的数量 <= 40，题目保证当迷宫中存在 M 时，一定存在至少一个 O 。
解决方案
题意概述
一个人在迷宫中，要从起点 S 走到终点 T。迷宫有两类特殊点，分别是：
M：机关点，需要用石头触发
O：石头点，一次可以搬一块石头
只有当所有 M 点均被触发以后，终点才可到达，问起点走到终点的最小代价。
题解
虽然迷宫有很多格子，但是我们实际上的走法只有几种：
- 从 S 走到 O，我们不会从 S 直接走到 M，因为触发机关要先搬石头。
- 从 O 走到 M
- 从 M 走到 O
- 从 M 走到 T
有一点性质很重要，不论我们触发机关或者搬运石头，都不改变迷宫的连通状态。因此，两个点的最短距离一旦计算出，就不会再改变了。
于是第一步，我们计算所有特殊点（包括 M，O，S，T）互相之间的最短距离，即对这里面的每个点做一次 bfs。这样我们就不需要考虑其他点了。
去除 O 点
现在，我们有：
M：最多 16 个
O：最多 40 个
S：1 个
T：1 个
这么多点需要考虑。其中 O 点是最多的，我们希望进一步缩小我们的考虑范围。
在最开始，我们一定会从 S，经过某一个 O，到达某一个 M。那么对于特定的 M 来说，我们枚举 O，并计算 S-O-M 的最短距离。那么如果我们要从起点到达 M，一定会选择这条距离最短的路。这样，我们首先得到了 S 到每一个 M 的最短距离。
假定我们已经从起点到达了某个 M 了，接下来需要去其他的 O 点搬石头接着触发其他的机关，这是一个 M-O-M' 的路线。同样的道理，对于给定的 M'，中间的 O 也是固定的。即给定 M 和 M'，我们可以确定一个 O，使得 M-O-M' 距离最短。我们同样可以记录下这个最短距离，即得到了 所有 M 到 M' 的最短距离。
最后，所有 M 到 T 的距离在前面已经计算出了。
状态压缩 DP
到这里，我们知道了 S 到所有 M 的最短距离，也知道了 M 互相之间的最短距离，也知道了 M 到 T 的最短距离，这就是一个经典的状态压缩 DP 的模型了。
令
其中
复杂度分析
- dp 复杂度：
。其中
为 M 点的数量。
- BFS 复杂度：
，其中
为 M 点的数量，
为 O 点的数量，
为迷宫的面积。
注意事项
- 由于本题的复杂度较高，使用 Python 等性能较差的语言实现时需要注意效率问题。
- 本题边界情况较多，比如迷宫没有 M 、M 不可达等。
Python 实现
import Queue
class Solution(object):
def minimalSteps(self, maze):
"""
:type maze: List[str]
:rtype: int
"""
n = len(maze)
m = len(maze[0])
p = []
#记录所有特殊点
for i in range(n):
for j in range(m):
if maze[i][j] in ['S','T','M','O']:
p.append((i,j,maze[i][j]))
dxs = [0,1,0,-1]
dys = [1,0,-1,0]
def bfs(x, y):
q = Queue.Queue()
q.put((x,y))
dis = [[10000 for i in range(m)] for j in range(n)]
dis[x][y] = 0
while not q.empty():
_ = q.get()
x = _[0]; y = _[1]
for dx, dy in zip(dxs, dys):
nx = x + dx; ny = y + dy
if nx < 0 or nx == n or ny < 0 or ny == m: continue
if maze[nx][ny] == '#': continue
if dis[nx][ny] > dis[x][y] + 1:
dis[nx][ny] = dis[x][y] + 1
q.put((nx,ny))
res = []
for i, j, _ in p:
res.append(dis[i][j])
return res
#计算特殊点之间的最短距离
tag = {}
dis = []
for idx, (i, j, t) in enumerate(p):
dis.append(bfs(i, j))
if not t in tag: tag[t] = []
tag[t].append(idx)
sidx = tag['S'][0]
tidx = tag['T'][0]
#特殊处理 M 不存在的情况
if not 'M' in tag:
ans = dis[sidx][tidx]
if ans == 10000:
ans = -1
return ans
#计算 S 到所有 M 点之间的最短距离
Mnum = len(tag['M'])
Onum = len(tag['O'])
dp = [[10000 for i in range(Mnum)] for i in range(1<<Mnum)]
for i in range(Mnum):
midx = tag['M'][i]
s = 1 << i
for j in range(Onum):
oidx = tag['O'][j]
dp[s][i] = min(dp[s][i], dis[sidx][oidx] + dis[oidx][midx])
# 预处理 M 点之间的最短距离
Mdis = [[10000 for i in range(Mnum)] for j in range(Mnum)]
for i in range(Mnum):
midx1= tag['M'][i]
for j in range(Mnum):
midx2 = tag['M'][j]
for k in range(Onum):
oidx = tag['O'][k]
Mdis[i][j] = min(Mdis[i][j], dis[midx1][oidx] + dis[oidx][midx2])
#状态压缩DP
for s in range(1<<Mnum):
for j in range(Mnum):
if s & (1<<j) == 0: continue
for k in range(Mnum):
if s & (1<<k) != 0: continue
ns = s | (1<<k)
dp[ns][k] = min(dp[ns][k], dp[s][j] + Mdis[j][k])
# 统计结果
ans = 10000
fs = (1<<Mnum) - 1
for j in range(Mnum):
midx = tag['M'][j]
ans = min(ans, dp[fs][j] + dis[midx][tidx])
if ans == 10000: ans = -1
return ansC++ 实现
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;
}
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()) {
auto 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();
vector<vector<int>> start_dist = bfs(sx, sy, maze);
// 边界情况：没有机关
if (nb == 0) {
return start_dist[tx][ty];
}
// 从某个机关到其他机关 / 起点与终点的最短距离。
vector<vector<int>> dist(nb, vector<int>(nb + 2, -1));
// 中间结果
vector<vector<vector<int>>> dd(nb);
for (int i = 0; i < nb; i++) {
vector<vector<int>> d = bfs(buttons[i].first, buttons[i].second, maze);
dd[i] = d;
// 从某个点到终点不需要拿石头
dist[i][nb + 1] = d[tx][ty];
}
for (int i = 0; i < nb; i++) {
int tmp = -1;
for (int k = 0; k < ns; k++) {
int mid_x = stones[k].first, mid_y = stones[k].second;
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]) {
tmp = dd[i][mid_x][mid_y] + start_dist[mid_x][mid_y];
}
}
}
dist[i][nb] = tmp;
for (int j = i + 1; j < nb; j++) {
int mn = -1;
for (int k = 0; k < ns; k++) {
int mid_x = stones[k].first, mid_y = stones[k].second;
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]) {
mn = dd[i][mid_x][mid_y] + dd[j][mid_x][mid_y];
}
}
}
dist[i][j] = mn;
dist[j][i] = mn;
}
}
// 无法达成的情形
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));
for (int i = 0; i < nb; i++) {
dp[1 << i][i] = dist[i][nb];
}
// 由于更新的状态都比未更新的大，所以直接从小到大遍历即可
for (int mask = 1; mask < (1 << nb); mask++) {
for (int i = 0; i < nb; i++) {
// 当前 dp 是合法的
if (mask & (1 << i)) {
for (int j = 0; j < nb; j++) {
// j 不在 mask 里
if (!(mask & (1 << j))) {
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];
}
}
}
}
}
}
int ret = -1;
int final_mask = (1 << nb) - 1;
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;
}
};
本文作者：力扣
声明：本文归“力扣”版权所有，如需转载请联系。
609
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
