nyoj--58--最少步数(bfs&dfs)

最新推荐文章于 2024-02-03 18:09:22 发布

原创最新推荐文章于 2024-02-03 18:09:22 发布 · 368 阅读

0 ·

CC 4.0 BY-SA版权

算法_搜索专栏收录该内容

9 篇文章

订阅专栏

本文介绍了一种求解迷宫中从起点到终点最少步数的问题，通过两种不同的算法实现：深度优先搜索（DFS）和广度优先搜索（BFS）。提供了完整的C++代码示例，帮助理解算法细节。

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

最少步数

时间限制：3000 ms | 内存限制：65535 KB

难度：4

描述

这有一个迷宫，有0~8行和0~8列：

1,1,1,1,1,1,1,1,1
1,0,0,1,0,0,1,0,1
1,0,0,1,1,0,0,0,1
1,0,1,0,1,1,0,1,1
1,0,0,0,0,1,0,0,1
1,1,0,1,0,1,0,0,1
1,1,0,1,0,1,0,0,1
1,1,0,1,0,0,0,0,1
1,1,1,1,1,1,1,1,1

0表示道路，1表示墙。

现在输入一个道路的坐标作为起点，再如输入一个道路的坐标作为终点，问最少走几步才能从起点到达终点？

（注：一步是指从一坐标点走到其上下左右相邻坐标点，如：从（3，1）到（4,1）。）

输入

第一行输入一个整数n（0<n<=100），表示有n组测试数据;
随后n行,每行有四个整数a,b,c,d（0<=a,b,c,d<=8）分别表示起点的行、列，终点的行、列。

输出

输出最少走几步。

样例输入

2
3 1  5 7
3 1  6 7

样例输出

12
11

dfs:

 C++ Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#include<bits/stdc++.h>
using namespace std;
int dx[4] = { -1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int c, step, ex, ey;
int Map[9][9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1,
                  1, 0, 0, 1, 0, 0, 1, 0, 1,
                  1, 0, 0, 1, 1, 0, 0, 0, 1,
                  1, 0, 1, 0, 1, 1, 0, 1, 1,
                  1, 0, 0, 0, 0, 1, 0, 0, 1,
                  1, 1, 0, 1, 0, 1, 0, 0, 1,
                  1, 1, 0, 1, 0, 1, 0, 0, 1,
                  1, 1, 0, 1, 0, 0, 0, 0, 1,
                  1, 1, 1, 1, 1, 1, 1, 1, 1
                };
void dfs(int x, int y, int c)
{
    if(x == ex && y == ey)
    {
        if(c < step)
            step = c;
    }
    for(int i = 0; i < 4; i++)
    {
        int xx = x + dx[i];
        int yy = y + dy[i];
        if(Map[xx][yy] == 0 && c < step - 1)
        {
            Map[xx][yy] = 1;
            dfs(xx, yy, c + 1);
            Map[xx][yy] = 0;
        }
    }
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        int x, y;
        c = 0;
        step = 9999;
        scanf("%d %d %d %d", &x, &y, &ex, &ey);
        Map[x][y] = 1;
        dfs(x, y, c);
        Map[x][y] = 0;
        printf("%d\n", step);
    }
    return 0;
}

bfs:

 C++ Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include<bits/stdc++.h>
using namespace std;
int dx[4] = { -1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int c, step, ex, ey;
int x, y;
int vis[9][9];
int Map[9][9] = { 1, 1, 1, 1, 1, 1, 1, 1, 1,
                  1, 0, 0, 1, 0, 0, 1, 0, 1,
                  1, 0, 0, 1, 1, 0, 0, 0, 1,
                  1, 0, 1, 0, 1, 1, 0, 1, 1,
                  1, 0, 0, 0, 0, 1, 0, 0, 1,
                  1, 1, 0, 1, 0, 1, 0, 0, 1,
                  1, 1, 0, 1, 0, 1, 0, 0, 1,
                  1, 1, 0, 1, 0, 0, 0, 0, 1,
                  1, 1, 1, 1, 1, 1, 1, 1, 1
                };
struct node
{
    int x, y, step;
};

int bfs()
{
    queue <node >qu;

    node s, now, next; ///s为第一个访问的节点
    s.x = x;
    s.y = y;
    s.step = 0;

    vis[x][y] = 1; ///对访问过的点进行标记

    qu.push(s);///第一个点入队
    while(!qu.empty())
    {
        now = qu.front(); ///把正在访问的点提出来
        qu.pop();  ///提出来后进行出队操作，把他相邻符合条件的点全部入队
        ///找到终点
        if(now.x == ex && now.y == ey)
            return now.step;

        for(int i = 0; i < 4; i++)
        {
            next.x = now.x + dx[i];
            next.y = now.y + dy[i];
            next.step = now.step;

            if(Map[next.x][next.y] == 0 && vis[next.x][next.y] == 0)
            {
                vis[next.x][next.y] = 1;
                next.step += 1;
                qu.push(next);
            }
        }
    }
}
int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        memset(vis, 0, sizeof(vis));
        scanf("%d %d %d %d", &x, &y, &ex, &ey);
        printf("%d\n", bfs());
    }
    return 0;
}