白书BFS宽度优先搜索

宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。

迷宫问题中和其他算法来解决最短路径问题。

假定有一个迷宫，S为迷宫开始，E为迷宫的结束，迷宫之中“.”为通路，"#",为墙壁，给定特殊迷宫，求能出去的最短路径。

迷宫小于100*100

输入m，n小于100

白书的写法：

 

#include <iostream>
#include <queue>
#include <cstring>
#include <algorithm>

using namespace std;

typedef pair<int,int> P;
char migong[102][102];
const int INF = 10000000;
int res,n,m;
int sx,sy;
int gx,gy;
int d[1000][1000];
int dx[4] = {1,0,-1,0};int dy[4] = {0,1,0,-1};
int bfs()
{
	queue<P> que;
	for(int i = 0;i < n;i++)
	{
		for(int j = 0;j < m;j++)
		{
			d[i][j] = INF;
		}
	}
	que.push(P(sx,sy));
	d[sx][sy] = 0;	
	while(que.size())
	{
		P p = que.front();
		que.pop();
		if(p.first == gx && p.second == gy)
		break;
		for(int i = 0;i < 4;i++)
		{
			int nx = p.first + dx[i],ny = p.second + dy[i];
			if(0 <= nx && nx< n && ny < m && ny >= 0 && migong[nx][ny] != '#' && d[nx][ny] == INF)
			{
				que.push(P(nx,ny));
				d[nx][ny] = d[p.first][p.second] + 1;
			}
		}
	}
	return d[gx][gy];
}
int main()
{
	cin >> m >> n;
	for(int i = 0;i < n;i++)
	{
		for(int j = 0;j <m;j++)
		{
			cin >> migong[i][j];
			if(migong[i][j] == 'S')
			{
				sx = i;
				sy = j;
			 } 
			 else if(migong[i][j] == 'E')
			 {
			 	gx = i;
			 	gy = j;
			 }
		}
	}
	cout << sx <<sy << gx <<gy <<endl;
	int res = bfs();
	for(int i = 0;i < n;++i)
	{
		for(int j = 0;j < n;++j)
		{
			cout << d[i][j];
		}
		cout << endl;
	 } 
	cout << res + 1 << endl;
}

---

个人写法以及见解：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>

using namespace std;

struct node
{
    int x;
    int y;
    int temp;
};
char map[102][102];
int map_bool[102][102];
int tx[4][4] = {0,1,0,-1,1,0,-1,0};//本地方可以使用二维数组来代替遍历的方向，组合分别为{0，1}{1，0}{-1，0}{0，-1}
int sx,sy;
int ex,ey;
int m,n;
int bfs(int sx,int sy)
{
    queue<node>que;
    node l,p;
    l.x = sx;
    l.y = sy;
    l.temp = 0;
    que.push(l);
    map_bool[l.x][l.y] = 0;
    while(!que.empty())
    {
        p = que.front();
        que.pop();
        if(p.x == ex && p.y == ey)
            return p.temp;
        for(int i = 0; i < 4; ++i)
        {
            int nx = p.x + tx[0][i],ny = p.y + tx[1][i];
            if(nx >= 0 && nx < m && ny >= 0 && ny < n && map_bool[nx][ny] == -1 && map[nx][ny] != '#')
            {
                node q;//这个地方注意结构体赋值：q = p，！！！！不正确；
必须一个值一个值的赋。
                q.x = nx;//这个地方注意结构体赋值：q = p，！！！！不正确；
必须一个值一个值的赋。
                q.y = ny;//这个地方注意结构体赋值：q = p，！！！！不正确；
必须一个值一个值的赋。
                q.temp = p.temp;//这个地方注意结构体赋值：q = p，！！！！不正确；
必须一个值一个值的赋。
                q.temp++;
                que.push(q);
                map_bool[nx][ny] = 0;
            }
        }
    }
}
int main()
{
    while(cin >> m >> n)
    {
        memset(map_bool,-1,sizeof(map_bool));//memset初始化为0或-1，其余的值都是乱码。
        for(int i = 0; i < m; ++i)
        {
            for(int j = 0; j < n; ++j)
            {
                cin >> map[i][j];
                if(map[i][j] == 'S')
                {
                    sx = i;
                    sy = j;
                }
                if(map[i][j] == 'E')
                {
                    ex = i;
                    ey = j;
                }
            }
        }
        cout << sx << sy << ex << ey <<endl;
        int t = bfs(sx,sy);
        for(int i = 0; i < m; ++i)
        {
            for(int j = 0; j < n; ++j)
            {
                cout << map_bool[i][j];
            }
            cout << endl;
        }
        cout << t <<endl;
    }
    return 0;
}