如果我们把问题的状态空间类比于一张图，广度优先搜索就相当于对这张图的广度优先遍历。我们可以借助一个队列实现广度优先搜索，起初，队列包含初始状态。在广搜的过程中，不断从队头取出状态，对于该状态面临的所有分支，把沿着每一条分支到达的下一个状态（如果尚未访问过或者能够被更新成更优的解）插入队尾。重复执行上述过程直至队列为空。
例题
这是一个典型的 “走地图”类问题，也就是给定一个矩形地图，控制一个物体在地图中按要求移动，求最小步数的问题。广搜很擅长解决这一类问题——地图的整体形态时固定不变的，只有少数个体或特征随着每一步的操作发生改变。我们只需要把这些 变化的部分提取为状态，把起始状态加入队列，使用广度优先搜索不断取出队头状态，沿着分支拓展，入队即可。广搜是逐层遍历搜索树的算法，所有状态按照入队的先后顺序具有层次单调性。如果每一次扩展刚好对应一步，那么当一个状态第一次被访问时，就得到了从起始状态到达该状态的最小步数。
在这道题中，不变的是地图，变化的部分是长方形的位置和放置形态。我们可以用一个三元组（x，y，lie）代表一个状态，执行·宽搜即可。
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
struct Data{
int x,y,state;
};
#define MAX_N 500
char a[MAX_N+5][MAX_N+5];
int v[MAX_N+5][MAX_N+5][5];
int d[3][4][3]={
{{-2,0,2},{1,0,2},{0,-2,1},{0,1,1}},
{{-1,0,1},{1,0,1},{0,-1,0},{0,2,0}},
{{-1,0,0},{2,0,0},{0,-1,2},{0,1,2}},
};
int n,m;
bool check(Data ne)
{
int x=ne.x,y=ne.y,s=ne.state;
if(x<1||x>n||y<1||y>m)return 0;
if(a[x][y]=='#')return 0;
if(s==0&&a[x][y]=='E')return 0;
if(s==1&&(y+1>m||a[x][y+1]=='#'))return 0;
if(s==2&&(x+1>n||a[x+1][y]=='#'))return 0;
return 1;
}
int bfs(Data start,Data ed)
{
memset(v,0,sizeof v);
queue<Data>q;
q.push(start);
while(q.size())
{
Data now=q.front();
q.pop();
for(int i=0;i<4;i++)
{
Data ne={now.x+d[now.state][i][0],now.y+d[now.state][i][1],d[now.state][i][2]};
int x=ne.x,y=ne.y,s=ne.state;
if(!check(ne))continue;
if(v[x][y][s])continue;
v[x][y][s]=v[now.x][now.y][now.state]+1;
q.push(ne);
}
}
return v[ed.x][ed.y][ed.state];
}
int main()
{
while(cin>>n>>m,n||m)
{
for(int i=1;i<=n;i++)cin>>a[i]+1;
Data start={-1},ed;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
if(start.x==-1&&a[i][j]=='X')
{
if(a[i][j+1]=='X')start.state=1;
else if(a[i+1][j]=='X')start.state=2;
else start.state=0;
start.x=i;
start.y=j;
}
if(a[i][j]=='O')
{
ed.x=i,ed.y=j,ed.state=0;
}
}
int ans=bfs(start,ed);
if(!ans)cout<<"Impossible"<<endl;
else cout<<ans<<endl;
}
return 0;
}
本问题相当于一个有多个起始状态的flood-fill问题，我们把A中的每一个1看作起点加入到队列当中。
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
typedef pair<int,int> PII;
#define MAX_N 1000
int n,m;
char a[MAX_N+5][MAX_N+5];
int b[MAX_N+5][MAX_N+5];
int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
void bfs()
{
queue<PII>q;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(a[i][j]=='1')
{
q.push({i,j});
b[i][j]=0;
}
while(q.size())
{
auto now=q.front();
q.pop();
for(int i=0;i<4;i++)
{
int x=now.first+dx[i],y=now.second+dy[i];
if(b[x][y]!=-1)continue;
if(x<1||x>n||y<1||y>m)continue;
q.push({x,y});
b[x][y]=b[now.first][now.second]+1;
}
}
return ;
}
int main()
{
cin>>n>>m;
memset(b,-1,sizeof b);
for(int i=1;i<=n;i++)scanf("%s",a[i]+1);
bfs();
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
printf("%d ",b[i][j]);
printf("\n");
}
return 0;
}
题解来源
分析题目中的四个要求：
1.箱子移动次数最少
2.在保证 1 的前提下，人的移动次数最少
3.在保证 1, 2 的前提下，箱子按照 N、S、W、E 的顺序优先选择移动方向
4.在保证 1, 2, 3 的前提下，人按照 n、s、w、e 的顺序优先选择移动方向
状态表示：
考虑把 人的坐标和箱子的坐标整体看做一个状态那么可以保证 人的移动次数+箱子的移动次数人的移动次数+箱子的移动次数最小，无法保证箱子的移动次数最小，所以不可取。
我们可以先假设我们可以任意的推箱子，而不考虑人怎么动。这样就可以保证箱子的移动次数最少。
那么我们就可以直接 bfs 求最短路。
然后对于我们所推的每一步，再对人做一遍 bfs，求出人到我们所推的位置即可。
举个例子：
如果我们宽搜时，箱子的下一步是往左走，那么我们就要同时 bfs 求出人到箱子右边的最短路。
但是我们在宽搜的时候，不能保证人一定能到我们所推的地方。
举个例子：
对于这张图，如果我们要把箱子向右推那么人就必须要走到箱子的左边，但是人并不能走到箱子的左边。
所以我们在宽搜的时候，对于箱子，我们不仅要记录它的坐标位置，还要记录它是从哪个方向推过来的。
然后就不难写出 bfs 了。
这里说下要注意的两点
1.对方向的加减
2.四个方向的枚举顺序
时间复杂度
最坏情况下，箱子会跑满地图，移动次数是 nm,
每次移动箱子，人都要响应的跑一遍 bfs最多移动 nm次，
所以总的时间复杂度貌似是
O
(
(
n
m
)
2
)
O((nm)^2)
O((nm)2)。
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
typedef pair<int, int> pii;
const int N = 25;
const int dx[4] = {1, -1, 0, 0}; // 存 人 对于 箱子 的四个位置的偏移量
const int dy[4] = {0, 0, 1, -1};
const char ops[5] = "nswe"; // 按题目要求的字典序存四个方向对应的字符
struct Point // 存每个位置的状态。由于要存过来的方向，所以用结构体存
{
int x, y; // 坐标位置
int dir; // 从哪边来的
};
int n, m; // 地图长宽
char g[N][N]; // 存地图
pii dist[N][N][4]; // 存到每个状态的最短距离。first 存箱子的移动距离，second 存人的移动距离
Point pre[N][N][4]; // 存箱子是从哪个状态转移过来的
vector<int> path[N][N][4]; // 存到每个状态的路径
bool st[N][N][4], vis[N][N]; // 对箱子做 bfs 时用 st 判重，对人做 bfs 时用 vis 判重
int pre_man[N][N]; // 存人是从哪个状态转移过来的
bool check(int x, int y) // 判断 (x, y) 这个格子是否可以走
{
return ~x && ~y && x < n && y < m && g[x][y] != '#';
}
// 对人做 bfs。判断人是否能从 start 走到 end 且不经过 box
// 如果能，将路径存入 seq 中，并返回路径长度；如果不能，则返回 -1
int bfs_man(pii start, pii end, pii box, vector<int> &seq)
{
memset(vis, false, sizeof vis); // 将 vis 初始化成 0
memset(pre_man, -1, sizeof pre_man); // 将 pre_man 初始化成 -1
vis[start.first][start.second] = true; // start 的位置不能走
vis[box.first][box.second] = true; // box 的位置不能走
queue<pii> q; q.push(start); // 将 start 加入队列
while (q.size())
{
pii t = q.front();
q.pop();
int x = t.first, y = t.second;
if (t == end) // 如果人到终点了
{
seq.clear(); // 先将 seq 清空
while (~pre_man[x][y]) // 然后反向往前求出走的路径
{
int dir = pre_man[x][y]; // 取出到 (x, y) 时，所走的方向
seq.push_back(dir); // 将该方向加入 seq
x += dx[dir], y += dy[dir]; // x 和 y 按该方向相反的方向走回去
}
return seq.size(); // 最后返回路径的长度
}
for (int i = 0; i < 4; i ++ )
{
// 由于 dx 和 dy 存的是人对于箱子的方向，和所要走的四个方向是反着的
// 直接用 + dx[i] 和 + dy[i] 也能遍历四个方向，但是无法保证字典序最小
// 所以这里要反过来，用 - dx[i] 和 - dy[i]
int a = x - dx[i], b = y - dy[i];
if (!check(a, b) || vis[a][b]) continue; // 如果 (a, b) 不能走，直接跳过
vis[a][b] = true; // 记录 (a, b) 已经被走过了
pre_man[a][b] = i; // 记录到 (a, b) 的方向为 i
q.push({a, b}); // 将 (a, b) 加入队列
}
}
return -1; // 如果无法到达 end，那么返回 -1
}
// 对箱子做 bfs，并返回是否能到达终点
bool bfs_box(pii start, pii box, Point &end)
{
memset(st, false, sizeof st); // 将 st 初始化为 false
queue<Point> q;
// 枚举四个相邻的位置，如果能从 box 到达该位置，那么将该位置加入队列
for (int i = 0; i < 4; i ++ )
{
int a = box.first + dx[i], b = box.second + dy[i]; // 人要走到的位置
int c = box.first - dx[i], d = box.second - dy[i]; // 箱子推到的位置
if (!check(a, b) || !check(c, d)) continue; // 如果 (a, b) 或 (c, d) 不能走，直接跳过
vector<int> seq; // 对人做一遍 bfs
// 传参含义：从 start 到 (a, b) 且不经过 box，将路径存入 seq 中
int len = bfs_man(start, {a, b}, box, seq);
if (len == -1) continue; // 如果返回值为 -1，说明不能走到，直接跳过
q.push({c, d, i}); // 否则能到，将该点加入队列中
st[c][d][i] = true; // 标记该点被经历过
path[c][d][i] = seq; // 到该点的路径为 seq
dist[c][d][i] = {1, len}; // 到该点的距离为：箱子被推了 1 步，人走了 len 步
// 记录该点是从 (box.first, box.second) 到达的，为了方便最后处理答案，将方向制为 -1
pre[c][d][i] = {box.first, box.second, -1};
}
pii maxd = {1e9, 1e9}; // 存到终点的最短距离，先初始化成一个巨大的数
while (q.size())
{
Point t = q.front(); // 取出队头
q.pop();
pii &v = dist[t.x][t.y][t.dir]; // 取出到队头状态的距离
// 如果到达了终点，并且距离比 maxd 更小，那么更新 maxd 并标记 end
if (g[t.x][t.y] == 'T' && v < maxd)
{
end = t;
maxd = v;
}
for (int i = 0; i < 4; i ++ )
{
int a = t.x + dx[i], b = t.y + dy[i]; // 人要走到的位置
int c = t.x - dx[i], d = t.y - dy[i]; // 箱子推到的位置
if (!check(a, b) || !check(c, d)) continue; // 如果 (a, b) 或 (c, d) 不能走，直接跳过
vector<int> seq;
// 箱子是从 t.dir 的方向被推过来的，所以推之前的位置就是 (t.x + dx[t.dir], t.y + dy[t.dir])
// 所以推完之后，人就应该在箱子原来的位置，也就是 (t.x + dx[t.dir], t.y + dy[t.dir])
int len = bfs_man({t.x + dx[t.dir], t.y + dy[t.dir]}, {a, b}, {t.x, t.y}, seq);
if (len == -1) continue; // 如果返回值为 -1，说明人到不了 (a, b)，直接跳过
pii distance = {v.first + 1, v.second + len}; // 否则能到，求出到这个状态的距离
if (!st[c][d][i]) // 如果 {c, d, i} 这个状态没被到过
{
q.push({c, d, i}); // 该状态入队
st[c][d][i] = true; // 标记这个状态被到过
path[c][d][i] = seq; // 到该状态的路径为 seq
dist[c][d][i] = distance; // 到该状态的距离为 distance
pre[c][d][i] = t; // 该状态是由 t 到达的
}
else if (dist[c][d][i] > distance) // 否则如果这次到达 {c, d, i} 的路径更近
{
dist[c][d][i] = distance; // 更新到达该状态的距离
path[c][d][i] = seq; // 将到达该状态的路径改为 seq
pre[c][d][i] = t; // 将该状态改为由 t 到达的
}
}
}
return maxd.first != 1e9; // 如果 maxd.first != 1e9 ，说明 maxd 被更新过，也就是能到达 end
}
int main()
{
for (int T = 0; scanf("%d%d", &n, &m), n || m;)
{
printf("Maze #%d\n", ++ T); // 先输出这是第几组数据
for (int i = 0; i < n; i ++ ) scanf("%s", g[i]); // 读入地图
pii start, box; // 找到人的位置和箱子的位置，分别存入 start 和 box 中
for (int i = 0; i < n; i ++ )
for (int j = 0; j < m; j ++ )
if (g[i][j] == 'S') start = make_pair(i, j);
else if (g[i][j] == 'B') box = make_pair(i, j);
Point end; string res; // end 存终点的位置，在 bfs 时记录即可。res 存答案
if (!bfs_box(start, box, end)) res = "Impossible."; // 如果到不了终点，要输出 Impossible.
else // 否则要找出到达终点的路径
{
while (~end.dir) // 被起点到达的状态的 dir 被标记成了 -1
{
res += ops[end.dir] - 32; // 存箱子移动的路径。小写字母 -32 变成大写字母
for (int i = 0; i < path[end.x][end.y][end.dir].size(); i ++ )
res += ops[path[end.x][end.y][end.dir][i]]; // 存人移动的路径
end = pre[end.x][end.y][end.dir]; // end 往前倒着找
}
reverse(res.begin(), res.end()); // 由于记录的序列是倒着的，最后要反转下再输出
}
cout << res << endl << endl; // 输出答案
}
return 0;
}
扫一扫
4637
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
