DFS與棧密切相關

則BFS與佇列密切相關

個人理解：BFS常用來搜最短路，它是一層一層的搜尋，因此它搜的距離一定是最短距離，需要用佇列儲存每一層的狀態，從根節點開始，根節點入隊，然後佇列不空，進入迴圈，取出佇列頭，開始擴充套件它下一層的點，如果這些點都符合要求，則把這些點都入隊，迴圈往復，直到最後佇列中元素為空，即搜尋完畢。

基本模板

void bfs()
{
      queue <- 第一個節點入佇列
      while queue不為空
      {
            t <- 取出隊頭（隊頭彈出）
            擴充套件t所有鄰點 x
            if x符合要求 並且 未被遍歷 未越界
            queue <- x
            d[x] = d[t] + 1 //第x層離根節點的距離
      }
}
 

如果想要輸入最短路徑 我們只需要讓path = t （即記錄當前的點是由哪個點擴充套件而來的）最後從後往前輸出即可

例題

迷宮

給定一個n*m的二維整數陣列，用來表示一個迷宮，陣列中只包含0或1，其中0表示可以走的路，1表示不可通過的牆壁。

最初，有一個人位於左上角(1, 1)處，已知該人每次可以向上、下、左、右任意一個方向移動一個位置。

請問，該人從左上角移動至右下角(n, m)處，至少需要移動多少次。

資料保證(1, 1)處和(n, m)處的數字為0，且一定至少存在一條通路。

輸入格式
第一行包含兩個整數n和m。

接下來n行，每行包含m個整數（0或1），表示完整的二維陣列迷宮。

輸出格式
輸出一個整數，表示從左上角移動至右下角的最少移動次數。

資料範圍
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

直接看程式碼,這個佇列是用陣列來實現的 當然也可直接用STL中的queue

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

using namespace std;

typedef pair<int, int> PII;
const int N = 110;

int g[N][N], d[N][N];
PII q[N*N];
int n, m;

int bfs()
{
    int hh = 0, tt = 0;

    q[0] = {0, 0};
    memset(d, -1, sizeof(d));
    d[0][0] = 0;

    while(hh <= tt)
    {
        auto t = q[hh++];

        int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
        for(int i = 0; i < 4; i++)
        {
            int x = t.first + dx[i], y = t.second + dy[i]; //由t點擴充套件而來
            if(x >= 0 && x < n && y >= 0 && y < m && d[x][y] == -1 && g[x][y] == 0)
            {
                d[x][y] = d[t.first][t.second] + 1;
                q[++tt] = {x, y};
            }
        } 
    }

    return d[n-1][m-1];
}

int main()
{
    cin >> n >> m;

    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < m; j++)
        {
            cin >> g[i][j];
        }
    }

    cout << bfs() << endl;
    system("pause");
    return 0;
}
 

如果想要輸出路徑的話，在bfs中進行改動

int bfs()
{
    queue<PII> q;

    memset(d, -1, sizeof(d));
    d[0][0] = 0;        
    q.push({0, 0});

    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

    while(q.size())
    {
        auto t = q.front();
        q.pop();

        for(int i = 0; i < 4; i++)
        {
            int x = t.first + dx[i], y = t.second + dy[i];

            if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
            {
                d[x][y] = d[t.first][t.second] + 1;
                p[x][y] = t; //記錄當前點是由哪個點擴充套件而來
                q.push({x, y});
            }
        }
    }

    int x = n-1, y = m-1;
    while(x || y) //從後往前
    {
        cout << x << " " << y << endl;
        PII t = p[x][y]; //記錄路徑
        x = t.first, y = t.second;
    }

    return d[n-1][m-1];
}