迷宫问题（BFS)

最新推荐文章于 2025-04-02 20:17:31 发布

原创最新推荐文章于 2025-04-02 20:17:31 发布 · 428 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#BFS

Algorithms 专栏收录该内容

99 篇文章

订阅专栏

本文介绍了一种使用BFS算法寻找从起点到终点最短路径的方法，并提供了详细的C语言实现代码。通过定义结构体元素来记录节点状态，利用队列进行节点遍历，最终输出寻路过程。

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

使用BFS算法，能求出最短的路径。

输入数据和前面一篇的一样。

下面贴出 BFS的实现：

#include <stdio.h>
#include <string.h>


struct element
{
    int value;
    int visit;
    int parent_x;
    int parent_y;
};

#define MAX_W    100
#define MAX_H    100

struct element data[MAX_W][MAX_H];

int start_x, start_y;
int end_x, end_y;

int M, N;
struct point
{
    int x, y;
};

#define is_safe(x,y)    ((x) < M && (y) < N && (x) >= 0 && (y) >= 0 && data[x][y].value == 1 && data[x][y].visit == 0)

struct point queue[MAX_W * MAX_H];
int head, tail, length;


void print_result(int x, int y)
{
    int parent_x = data[x][y].parent_x;
    int parent_y = data[x][y].parent_y;

    if(parent_x != -1 && parent_y != -1)
    {
        print_result(parent_x, parent_y);
    }    
    if(x != end_x ||  y != end_y)
    {
        printf("(%d,%d) --> ", x, y);
    }
    else
    {
        printf("(%d %d)\n", x, y); 
    }
}

void search(int x, int y)
{
    while(length > 0)
    {
        struct point p = queue[head];
        length--;
        head = (head + 1) % (MAX_W * MAX_H);

        
        int x = p.x;
        int y = p.y;
        if(x == end_x && y == end_y)
        {
            printf("path found!\n");
            print_result(x, y);
            break;
        }
        if(is_safe(x, y+1))
        {
            data[x][y+1].visit = 1;
            tail = (tail + 1) %(MAX_W * MAX_H);
            length++;
            queue[tail].x = x;
            queue[tail].y = y + 1;
            data[x][y+1].parent_x = x;
            data[x][y+1].parent_y = y;
        }


        if(is_safe(x, y-1))
        {
            data[x][y-1].visit = 1;
            tail = (tail + 1)%(MAX_W * MAX_H);
            length++;
            queue[tail].x = x;
            queue[tail].y = y - 1;
            data[x][y-1].parent_x = x;
            data[x][y-1].parent_y = y;
        }


        if(is_safe(x+1, y))
        {
            data[x+1][y].visit = 1;
            tail = (tail + 1)%(MAX_W * MAX_H);
            length++;
            queue[tail].x = x + 1;
            queue[tail].y = y;
            data[x+1][y].parent_x = x;
            data[x+1][y].parent_y = y;
        }


        if(is_safe(x-1, y))
        {
            data[x-1][y].visit = 1;
            tail = (tail + 1)%(MAX_W * MAX_H);
            length++;
            queue[tail].x = x-1;
            queue[tail].y = y;
            data[x+1][y].parent_x = x;
            data[x+1][y].parent_y = y;
        }

    }
}

int main(int argc, char **argv)
{
    FILE *fp = freopen("data.txt", "r", stdin);
    if(fp == NULL)
    {
        return -1;
    }

    scanf("%d %d", &M, &N);
    
    memset(data, 0, sizeof(data));

    int i, j;
    for(i = 0; i < M; i++)
    {
        for(j = 0; j < N; j++)
        {
            scanf("%d", &data[i][j].value);
            if(data[i][j].value == 2)
            {
                start_x = i;
                start_y = j;
            }
            else if(data[i][j].value == 3)
            {
                end_x = i;
                end_y = j;
                data[i][j].value = 1;
            }
        }
    }

    data[start_x][start_y].visit = 1;
    data[start_x][start_y].parent_x = -1;
    data[start_x][start_y].parent_y = -1;
    head = tail = length = 0;
    queue[tail].x = start_x;
    queue[tail].y = start_y;
    length++;
    search(start_x, start_y);

    return 0;
}

输出结果：

path found!
(0,0) --> (1,0) --> (1,1) --> (1,2) --> (1,3) --> (1,4) --> (1,5) --> (2,5) --> (3,5) --> (4 5)