1、迷宫最短路
AcWing 844. 走迷宫
给定一个
n
×
m
n×m
n×m的二维整数数组，用来表示一个迷宫，数组中只包含
0
0
0 或
1
1
1，其中
0
0
0 表示可以走的路，
1
1
1 表示不可通过的墙壁。
最初，有一个人位于左上角 ( 1 , 1 ) (1,1) (1,1)处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。
请问，该人从左上角移动至右下角 ( n , m ) (n,m) (n,m) 处，至少需要移动多少次。数据保证 ( 1 , 1 ) (1,1) (1,1)处和 ( n , m ) (n,m) (n,m)处的数字为 0 0 0，且一定至少存在一条通路。
输入格式
第一行包含两个整数
n
n
n和
m
m
m。
接下来 n行，每行包含 m个整数（0 或 1），表示完整的二维数组迷宫。
输出格式
输出一个整数，表示从左上角移动至右下角的最少移动次数。
数据范围
1
≤
n
,
m
≤
100
1≤n,m≤100
1≤n,m≤100
输入样例：
5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出样例：
8
问题分析：
如下图所示，从起点开始，在迷宫中每走一步的过程转化为广度优先遍历中的遍历与上一层节点距离为1的节点。因此，利用BFS的原理，此时我们只需要将符合要求每一层的节点(即符合要求的每一步路径走法）依次枚举出来，并且将节点是否是第一次访问到进行标记（即迷宫的该位置是否第一次走到进行标记），当我到达终点时，我们就能得出走出迷宫的最短路径时多少，并且还可以输出对应的路径。
图中，描述的就是模拟样例，逐层枚举所有符合要求的的节点的过程，每一轮过程，都会新加入一层节点（即图中所示，每一轮会多一种颜色的点被圈起来，代表这一层节点被加入。如果为了更清晰可以将圈起来的所有点画成一个图进行理解）。
AC代码如下：
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N = 110;
int n, m;
//记录地图和某个点的最短距离
int g[N][N], d[N][N];
typedef pair<int, int >PII;
void bfs_max_path() {
queue<PII> q;
// 初始化所有点的最短距离为-1
memset(d, -1, sizeof (d));
//起点的最短距离为0
d[0][0] = 0;
q.push({ 0,0 });
//x 方向的向量和 y 方向的向量组成的上、右、下、左
int dx[4] = { -1, 0, 1, 0 }, dy[4] = { 0, 1, 0, -1 };
while (!q.empty()) {
//队列不空的情况
//取队头元素
auto t = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
//x,y沿着四个方向寻找路径
int x = t.first + dx[i], y = t.second + dy[i];
//xy在边界内，并且g[x][y]=0是空地可以走，并且之前没走过的情况
if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1) {
//起点到当前(x,y)的最短距离，是起点到上一个点的最短距离 + 1
d[x][y] = d[t.first][t.second]+1;
//广搜的下一层的节点入队
q.push({ x,y });
}
}
}
return;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> g[i][j];
}
}
bfs_max_path();
cout << d[n-1][m-1] << endl;
return 0;
}
拓展
附带输出路径的代码如下：
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
typedef pair<int, int >PII;
const int N = 110;
int n, m;
//记录地图和某个点的最短距离
int g[N][N], d[N][N];
//记录每个点最短路径的前驱节点
PII prevNode[N][N];
void bfs_max_path() {
queue<PII> q;
// 初始化所有点的最短距离为-1
memset(d, -1, sizeof (d));
//起点的最短距离为0
d[0][0] = 0;
q.push({ 0,0 });
//x 方向的向量和 y 方向的向量组成的上、右、下、左
int dx[4] = { -1, 0, 1, 0 }, dy[4] = { 0, 1, 0, -1 };
while (!q.empty()) {
//队列不空的情况
//取队头元素
auto t = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
//x,y沿着四个方向寻找路径
int x = t.first + dx[i], y = t.second + dy[i];
//xy在边界内，并且g[x][y]=0是空地可以走，并且之前没走过的情况
if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1) {
//起点到当前(x,y)的最短距离，是起点到上一个点的最短距离 + 1
d[x][y] = d[t.first][t.second]+1;
//广搜的下一层的节点入队
q.push({ x,y });
//保存前驱节点为上一个节点
prevNode[x][y]=t;
}
}
}
return;
}
void print_path() {
if (d[n - 1][m - 1] == -1) {
cout << "无法到达终点" << endl;
return;
}
vector<PII> path;
for (PII at = {n - 1, m - 1}; at != make_pair(0, 0); at = prevNode[at.first][at.second]) {
path.push_back(at);
}
path.push_back({0, 0}); // 添加起点
reverse(path.begin(), path.end()); // 反转路径，因为我们是从终点回溯到起点的
for (auto p : path) {
cout << '(' << p.first << ',' << p.second << ')' << "->";
}
cout << "终点" << endl;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> g[i][j];
}
}
bfs_max_path();
cout << "最短路径长度: " << d[n - 1][m - 1] << endl;
print_path();
return 0;
}
2、八数码（滑动谜题）
AcWing 845. 八数码
滑动谜题和八数码类似
在一个 3×3 的网格中，1∼8这 8个数字和一个 x 恰好不重不漏地分布在这 3×3的网格中。
例如：
1 2 3
x 4 6
7 5 8
在游戏过程中，可以把 x 与其上、下、左、右四个方向之一的数字交换（如果存在）。
我们的目的是通过交换，使得网格变为如下排列（称为正确排列）：
1 2 3
4 5 6
7 8 x
例如，示例中图形就可以通过让 x 先后与右、下、右三个方向的数字交换成功得到正确排列。
交换过程如下：
1 2 3 1 2 3 1 2 3 1 2 3
x 4 6 4 x 6 4 5 6 4 5 6
7 5 8 7 5 8 7 x 8 7 8 x
现在，给你一个初始网格，请你求出得到正确排列至少需要进行多少次交换。
输入格式
输入占一行，将 3×3的初始网格描绘出来。
例如，如果初始网格如下所示：
1 2 3
x 4 6
7 5 8
则输入为：1 2 3 x 4 6 7 5 8
输出格式
输出占一行，包含一个整数，表示最少交换次数。
如果不存在解决方案，则输出 −1。
输入样例：
2 3 4 1 5 x 7 6 8
输出样例
19
问题分析：
首先，本题要求求出最少步数，所以此时第一反应想到的应该是采用BFS解题。
如何将问题进行转化？
将每次寻找交换位置整个九宫格中X（即空位置）发生变化后的状态的过程转化为广度优先遍历中寻找每一层节点的过程，当利用BFS能够将X（即空位置）推移到终点时，我们就能找到X达到终点所需要的最小步数。
如下图所示，模拟样例找到最短路径的过程即找到使用最少步数的过程。根据BFS算法的性质，该过程中，树的每个分支的节点都只对应一种推移交换后的状态，每层的节点数就是符合题目要求的所有状态数，而节点所在层数则是代表到达该状态，所需要推移交换的最少步数。
已知输入初始状态为1 2 3 x 4 6 7 5 8的字符串，如何将每次的状态对应记录下来呢？
按理来说，我们只需要将每个状态的字符串与
3
×
3
3×3
3×3九宫格的状态一一对应即可，字符串变为12345678X，即可认为状态已经达到图中模拟的最终状态（即满足要求的状态）。此时，就可以输出最小步数了。由此，采用下图所示的下标映射方法，利用字符串来保存状态
考虑好上面的状态保存之后，此时我们需要
1、用一个队列保存当前获得的序列。
2、用一个哈希表保存各个序列与对应额交换次数（避免不知道交换次数是几）。
由此，得出AC代码如下：
#include<iostream>
#include<queue>
#include<unordered_map>
#include<algorithm>
using namespace std;
int BFS(string start) {
//定义最终状态
string end = "12345678x";
//所需的队列
queue<string> q;
//所需的哈希map
unordered_map<string, int >dist;
//初始化
q.push(start);
//交换0次
dist[start] = 0;
//定义坐标交换方式,(x,y)组合成与上、右、下、左进交换
int dx[4] = { -1, 0, 1, 0 }, dy[4] = { 0, 1, 0, -1 };
//广搜
while (!q.empty()) {
//暂存队列弹出的元素
auto t = q.front();
q.pop();
//暂存一下到达当前状态的最短步数
int distance = dist[t];
//判断状态可以结束
if (t == end) return distance;
//找到x在字符串中的下标
int k = t.find('x');
//计算映射后的（x,y）,
//横轴向右为y轴，纵轴向下为x轴；
int x = k / 3;
int y = k % 3;
//开始进行交换，广搜有效解
//根据上述定义的dx，dy进行状态交换
for (int i = 0; i < 4; i++) {
int a = x + dx[i], b = y + dy[i];
//判断是否符合条件
if (a >= 0 && a < 3 && b >= 0 && b < 3) {
//符合条件，先得到下一层的节点{x,y}转化为字符串
//交换原来下标和现在下标对应的字符
swap(t[k], t[a * 3 +b]);
//第一次访问则入队
if (!dist.count(t)) {
dist[t] = distance + 1;
q.push(t);
}
//广搜下一层的第一个节点操作完成
//恢复原来状态，方便下一次状态转移（每次会进行4次状态转移循环）
swap(t[k], t[a * 3 + b]);
}
}
}
//到达不了
return -1;
}
int main(){
string start;
for (int i = 0; i < 9; i++) {
//题目输入是一个一个读入的
char c;
cin >> c;
start += c;
}
cout << BFS(start) << endl;
return 0;
}
1017
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
