宽度优先探索（bfs）

思想：从起始点出发，探索周围的点，直到结束

框架：

BFS(int x, int y, int z)
{
         queue<type> q;
         while(!q.empty())
           {
                    q.pop();
                   for(遍历四周)
                       if(满足条件)
                               q.push();
             }
}

例题 poj 3984

迷宫问题

定义一个二维数组：

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

int maze[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,

};

Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output

左上角到右下角的最短路径，格式如样例所示。

Sample Input

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

Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

#include <iostream>
#include <cstdio>
#include <queue>
#include <stack>
#include <utility>

using namespace std;
int maze[6][6] = {0};
int direction[6][6][2] = {0};
int vis[6][6] = {0};
struct road
{
int i;
int j;
int step;
};

struct a
{
    int x;
    int y;
};
stack<a> b;
bool check(int i, int j)
{
    if(i>=1&&i<=5)
        if(j >= 1&&j <= 5)
        return true;
    return false;
}
void bfs()
{
    queue<road> q;
    q.push({1,1,0});
    vis[1][1] = 1;
    while(!q.empty())
    {
        road t = q.front();
        q.pop();
        if(t.i == 5&&t.j == 5)
            {
                int temx =  5,temy = 5;
                b.push({temx,temy});
                while(1)
                {
                    if(temx == 1&&temy == 1)
                        break;
                    int t1 = temx;// 这个地方，不能用temx，temy用于下面direction。
                    int t2 = temy;
                    temx += direction[t1][t2][0];
                    temy += direction[t1][t2][1];
                    b.push({temx,temy});
                }

                break;
            }
        if(maze[t.i + 1][t.j] == 0&&check(t.i + 1,t.j)&&!vis[t.i + 1][t.j])
        {
            direction[t.i + 1][t.j][0] = -1;
            direction[t.i + 1][t.j][1] = 0;
            q.push({t.i + 1, t.j, t.step + 1});
            vis[t.i + 1][t.j] = 1;
        }
        if(maze[t.i][t.j + 1] == 0&&check(t.i,t.j + 1)&&!vis[t.i][t.j + 1])
        {
            direction[t.i][t.j + 1][0] = 0;
            direction[t.i][t.j + 1][1] = -1;
            q.push({t.i, t.j + 1, t.step + 1});
            vis[t.i][t.j + 1] = 1;
        }
        if(maze[t.i - 1][t.j] == 0&&check(t.i - 1,t.j)&&!vis[t.i - 1][t.j])
        {
            direction[t.i - 1][t.j][0] = 1;
             direction[t.i - 1][t.j][1] = 0;

            q.push({t.i - 1, t.j, t.step + 1});
            vis[t.i - 1][t.j] = 1;
        }
        if(maze[t.i][t.j - 1] == 0&&check(t.i,t.j - 1)&&!vis[t.i][t.j - 1])
        {
            direction[t.i][t.j - 1][0] = 0;
            direction[t.i][t.j - 1][1] = 1;
            q.push({t.i, t.j - 1, t.step + 1});
            vis[t.i][t.j - 1] = 1;
        }
    }

}

int main()
{
   for(int i = 1; i <= 5; i ++)
    for(int j = 1; j <= 5; j ++)
   {
       scanf("%d", &maze[i][j]);
   }
   bfs();
   while(!b.empty())
   {
       a t = b.top();
       printf("(%d, %d)\n", t.x - 1, t.y - 1);
       b.pop();
   }
    return 0;
}

教训：1变量尽量不要用于找数组的元素，因为变量有可能变，和所要找的数组的特定位置不符。

2bfs要记录路径的话，最好用回溯法。用方向数组记录父节点的位置。