以前學習C的時候，老師佈置過一個拓展作業，實現迷宮的求解，當時沒有學習資料結構，有點難以下手，現在學完資料結構已經將近2年，終於解決了這個問題。

給定一個n*m大小的迷宮，其中*代表不可通過的牆壁，”.”代表平地，S代表起點，T代表終點。每次只能 上下左右移動，求S到T的最短步數。（詳見演算法筆記P278）

這是一個搜尋問題，利用BFS實現思路很簡單，當從S廣搜到T時，當前的層數就是最短的步數。

#include<cstdio>
#include<cstring>
#include<queue>

using namespace std
 
;

const int maxn = 100;
struct Node
{
    int x, y;
    int step;
}S, T, node;

int n, m;  //n * m
char maze[maxn][maxn];
bool inq[maxn][maxn] = {false};
int X[4] = {0, 0, 1, -1};
int Y[4] = {1, -1, 0, 0};

bool test(int x, int y)
{
    if(x >= n || x < 0 || y >= m || y < 0)
        return false;
    if
 
(maze[x][y] == '*')
        return false;
    if(inq[x][y] == true)
        return false;
    return true;
}

int BFS()
{
    queue<Node> q;
    S.step = 0;
    inq[S.x][S.y] = true;
    q.push(S);

    while(!q.empty())
    {
        Node top = q.front();
        q.pop();
        if(top.x == T.x && top.y == T.y)
            return
 
 top.step;
        for(int i = 0; i < 4; ++i)
        {
            int newX = top.x + X[i];
            int newY = top.y + Y[i];
            if(test(newX, newY))
            {
                node.x = newX;
                node.y = newY;
                node.step = top.step + 1;
                q.push(node);
                inq[newX][newY] = true;
            }

        }
    }
    return -1;
}

int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; ++i)
    {
        getchar();
        for(int j = 0; j < m; ++j)
        {
            maze[i][j] = getchar();
        }
    }
    scanf("%d%d%d%d", &S.x, &S.y, &T.x, &T.y);
    printf("%d\n", BFS());
    return 0;
}

執行截圖：