[BFS] POJ 3984

最新推荐文章于 2022-11-11 09:39:42 发布

pppqq77223434

最新推荐文章于 2022-11-11 09:39:42 发布

阅读量239

点赞数

CC 4.0 BY-SA版权

分类专栏： ACM kuangbin专题一简单搜索

本文链接：https://blog.youkuaiyun.com/Aria461863631/article/details/78430410

ACM 同时被 2 个专栏收录

110 篇文章

订阅专栏

kuangbin专题一简单搜索

13 篇文章

订阅专栏

本文介绍了一种使用数组和广度优先搜索（BFS）算法实现迷宫寻路的方法。通过递归地打印路径，从起点(0,0)到终点(4,4)，并记录每个节点的状态及其父节点，最终输出一条有效的路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

回溯

（这次写的没那么乱七八糟了）

用数组来存每一个节点，并记录父节点的位置

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

using namespace std;

int map[ 6 ][ 6 ], vis[ 6 ][ 6 ];
int pre[ 120 ];

struct Node {
        int x, y;
        int cnt;
        int indx; //储存在数组里的位置
        int pre;  //储存父亲的位置

} log[ 120 ]; //用数组来储存每个节点

int dirx[ 4 ] = {1, -1, 0, 0};
int diry[ 4 ] = {0, 0, 1, -1};

bool path ( int x, int y ) {
        if ( x >= 0 && x < 5 && y >= 0 && y < 5 && map[ x ][ y ] == 0 )
                return true;
        return false;
}

//递归打印
void Print ( int c ) {
        if ( c == 0 ) {
                printf ( "(0, 0)\n" );
                return;
        }
        Print ( log[ c ].pre );
        printf ( "(%d, %d)\n", log[ c ].x, log[ c ].y );
}

void bfs () {
        memset ( vis, false, sizeof ( vis ) );
        // 0,0为起点
        int tail = 0;
        log[ tail ].x = log[ tail ].y = 0;
        log[ tail ].cnt = 0;
        log[ tail ].indx = tail;
        log[ tail ].pre = 0;
        vis[ 0 ][ 0 ] = true;

        tail++;

        queue<Node> q;
        q.push ( log[ tail ] );

        while ( !q.empty () ) {
                Node cur = q.front ();
                q.pop ();

                if ( cur.x == 4 && cur.y == 4 ) {
                        Print ( cur.indx );
                        return;
                }

                for ( int i = 0; i < 4; ++i ) {
                        Node nex;
                        nex.x = cur.x + dirx[ i ];
                        nex.y = cur.y + diry[ i ];
                        nex.cnt = cur.cnt + 1;

                        if ( !vis[ nex.x ][ nex.y ] && path ( nex.x, nex.y ) ) {
                                vis[ nex.x ][ nex.y ] = true;
                                log[ tail ].x = nex.x;
                                log[ tail ].y = nex.y;
                                log[ tail ].cnt = nex.cnt;
                                log[ tail ].pre = cur.indx;
                                log[ tail ].indx = tail;
                                q.push ( log[ tail ] );
                                ++tail;
                        }
                }
        }
}

int main () {
        for ( int i = 0; i < 5; ++i )
                for ( int j = 0; j < 5; ++j )
                        scanf ( "%d", &map[ i ][ j ] );

        bfs ();

        return 0;
}