LCP 13. 寻宝(C++)---状态压缩 动态规划 + BFS

题目详情

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

迷宫是一个二维矩阵，用一个字符串数组表示。它标识了唯一的入口（用 '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 <= 100
• 1 <= maze[i].length <= 100
• maze[i].length == maze[j].length
• S 和 T 有且只有一个
• 0 <= M的数量 <= 16
• 0 <= O的数量 <= 40，题目保证当迷宫中存在 M 时，一定存在至少一个 O 。

 

——题目难度:困难


 

---

-BFS + DP + 状态压缩 解题代码

class Solution {
public:
	int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
	int 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> t = q.front();
			q.pop();
			int tx = t.first, ty = t.second;
			for(int i = 0; i < 4; i++) {
				int nx = tx + dirs[i][0], ny = ty + dirs[i][1];
				if (nx >= 0 && nx < n && ny >= 0 && ny < m && maze[nx][ny] != '#' && ret[nx][ny] == -1) {
					ret[nx][ny] = ret[tx][ty] + 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});
				}
				else if (maze[i][j] == 'O') {
					stones.push_back({i, j});
				}
				else if (maze[i][j] == 'S') {
					sx = i;
					sy = j;
				}
				else 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];
		}
		
		//从某个机关到其他机关 / 起点与终点的最短距离
		//dist[i][nb] 表示 从开始位置 到 某个石头 再到 第 i + 1 个机关 的最短距离 
		//dist[i][nb + 1] 表示 从第 i + 1 个机关 直接到 终点 的最短距离 
		vector<vector<int>> dist(nb, vector<int>(nb + 2, -1));
		// dd用于存储中间结果 --- 每个机关到矩阵中的各个点的距离 
		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 temp = -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 (temp == -1 || temp > dd[i][mid_x][mid_y] + start_dist[mid_x][mid_y]) {
						temp = dd[i][mid_x][mid_y] + start_dist[mid_x][mid_y];
					}
				}
			}
			dist[i][nb] = temp;
			
			//计算第 i + 1 个机关 到 第 j + 1 个机关的 最短距离 
			for(int j = i + 1; j < nb; j++) {
				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 && dd[j][mid_x][mid_y] != -1) {
						if (tmp == -1 || tmp > dd[i][mid_x][mid_y] + dd[j][mid_x][mid_y]) {
							tmp = dd[i][mid_x][mid_y] + dd[j][mid_x][mid_y];
						}
					}
				}
				dist[i][j] = tmp;
				dist[j][i] = tmp;
			}
		}
			
			// 无法达成的情形
			for(int i = 0; i < nb; i++) {
				if (dist[i][nb] == -1 || dist[i][nb + 1] == -1) return -1;
			}
			
			// dp[mask][i] 表示当前在第 i 个 M 处，触发状态为 mask 的最小步数， -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) - 1 ; mask++) {
				for(int i = 0; i < nb; i++) { // i为 第几个 M 开始出发 
					if (mask & (1 << i)) { //选择出发点
						for(int j = 0; j < nb ; j++) { 
							if (!(mask & (1 << j))) { // j 要是还没有去到过的 M 
								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 ans = -1;
			int final_mask = (1 << nb) - 1;
			for(int i = 0; i < nb; i++) {
				if (ans == -1 || ans > dp[final_mask][i] + dist[i][nb + 1]) {
					ans = dp[final_mask][i] + dist[i][nb + 1];
				}
			}
			
			return ans;		
    }
};

结果