POJ-3984-迷宫问题（BFS）

最新推荐文章于 2020-04-13 20:53:32 发布

转载最新推荐文章于 2020-04-13 20:53:32 发布 · 72 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/gaojinmanlookworld/p/10586867.html

本文介绍了一种使用广度优先搜索(BFS)算法解决迷宫问题的方法，通过定义迷宫结构并实现BFS算法，成功地找到了从起点到终点的最短路径。

迷宫问题

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 33522		Accepted: 19106

Description

定义一个二维数组：

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,

};

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

Input

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

Output

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

Sample Input

Sample Output

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

#include <iostream>
#include <cstring>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;

int MAP[10][10];
bool visit[10][10];
int dir[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};

struct MiGong
{
    int x, y;
    int fa, ma;
};

MiGong M[10][10], v;

void BFS ( int x, int y )
{
    queue <MiGong> Q;
    visit[x][y] = true;
    Q.push( M[x][y] );
    //int X = 1;
    while( !Q.empty() )
    {
        //for( int i=0; i<X; i++ )
        //cout << "你个智障，死循环了";
        //cout << endl;
        //X++;
        v = Q.front();
        Q.pop();
        //cout << "**" << endl;
        if( v.x == 4 && v.y == 4 )
            break;

        struct MiGong now;
        for( int i=0; i<=4; i++ )
        {
            now.x = v.x + dir[i][0];
            now.y = v.y + dir[i][1];
            now.fa = v.x;
            now.ma = v.y;

            //cout << "##" << endl;
            if( now.x >= 0 && now.y >= 0 && now.x < 5 && now.y < 5 )

                if( !visit[now.x][now.y] && !MAP[now.x][now.y] )
                {
                    visit[now.x][now.y] = true;
                    Q.push( now );
                    M[now.x][now.y] = now;
                    //cout << "#" << endl;
                }
        }
        /*if( M[v.x-1][v.y].data == 0 )
        {
            Q.push( M[v.x-1][v.y] );
            M[v.x-1][v.y].fa = v.x-1;
            M[v.x-1][v.y].ma = v.y;
            M[v.x-1][v.y].data = -1;
        }
        if( M[v.x][v.y-1].data == 0 )
        {
            Q.push( M[v.x][v.y-1] );
            M[v.x][v.y-1].fa = v.x;
            M[v.x][v.y-1].ma = v.y-1;
            M[v.x][v.y-1].data == -1;
        }
        if( M[v.x+1][v.y].data == 0 )
        {
            Q.push( M[v.x+1][v.y] );
            M[v.x+1][v.y].fa = v.x+1;
            M[v.x+1][v.y].ma = v.y;
            M[v.x][v.y-1].data == -1;
        }
        if( M[v.x][v.y+1].data == 0 )
        {
            Q.push( M[v.x][v.y+1] );
            M[v.x][v.y+1].fa = v.x;
            M[v.x][v.y+1].ma = v.y+1;
            M[v.x][v.y-1].data == -1;
        }*/
    }

    stack <MiGong> S;
    while( v.fa != -1 && v.ma != -1 )
    {
        S.push(v);
        //cout << "(" << v.x << "," << v.y << ")" << endl;
        v = M[v.fa][v.ma];
    }
    S.push(v);
    while( !S.empty() )
    {
        v = S.top();
        S.pop();
        cout << "(" << v.x << ", " << v.y << ")" << endl;
    }
}


int main()
{
    memset( MAP, 1, sizeof(MAP));
    int i, j;
    for( i=0; i<5; i++ )
        for( j=0; j<5; j++ )
        {
            cin >> MAP[i][j];
            M[i][j].x = i;
            M[i][j].y = j;
            M[i][j].fa = -1;
            M[i][j].ma = -1;
        }

    BFS( 0, 0 );

    return 0;
}

转载于:https://www.cnblogs.com/gaojinmanlookworld/p/10586867.html