洛谷 P1825 Corn Maze S 广度优先搜索 做题经历

最新推荐文章于 2024-11-09 21:51:15 发布
最新推荐文章于 2024-11-09 21:51:15 发布
阅读量162 收藏 1
点赞数 1
文章标签： 宽度优先 深度优先 算法 c++ stl 广度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65708726/article/details/132916240
版权

[USACO11OPEN] Corn Maze S | P1825 BFS

这题主要就是坑点比较多，写代码并不复杂，算法也不复杂。

首先一看题目DFS（深度优先搜索）好像可以，因为DFS就是模拟奶牛往下走的过程嘛，也不难写然后就有了第一版的代码：

#include <bits/stdc++.h>
using namespace std;
int N, M;
struct point
{
    int i, j;
};
char place[301][301];
map<char, list<struct point> > transit;
bool path[301][301];
int min_time = 999999;
int start_i, start_j, end_i, end_j;
bool dfs(int count, int i, int j)
{
    // cout << count << ' ' << place[i][j] << ' ' << i << ' ' << j << endl;
    if (place[i][j] == '#' || path[i][j])
    {
        return false;
    }
    if (i == end_i && j == end_j)
    {
        min_time = min(count, min_time);
        return true;
    }
    path[i][j] = true;
    if (place[i][j] >= 'A' && place[i][j] <= 'Z')
    {

        list<struct point>::iterator it1 = transit[place[i][j]].begin();
        for (; it1 != transit[place[i][j]].end(); it1++)
        {
            if ((*it1).i != i && (*it1).j != j)
                dfs(count, (*it1).i, (*it1).j);
        }
    }
    dfs(count + 1, i, j - 1);
    dfs(count + 1, i, j + 1);
    dfs(count + 1, i - 1, j);
    dfs(count + 1, i + 1, j);
    path[i][j] = false;
    return false;
}
int main()
{
    cin >> N >> M;
    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= M; j++)
        {
            cin >> place[i][j];
            if (place[i][j] == '@')
            {
                start_i = i;
                start_j = j;
            }
            if (place[i][j] == '=')
            {
                end_i = i;
                end_j = j;
            }
            if (place[i][j] >= 'A' && place[i][j] <= 'Z')
            {
                struct point p = {i, j};
                transit[place[i][j]].insert(transit[place[i][j]].end(), p);
            }
        }
    }
    dfs(0, start_i, start_j);
    cout << min_time;
    return 0;
}

然后就只拿了12分，奇怪了，为什么会这样，明明就是按照题目写的，还有一堆TLE的，索性先不管TLE的先把WA的处理了。
在这里插入图片描述
然后发现了第一个bug

            if ((*it1).i != i && (*it1).j != j)
                dfs(count, (*it1).i, (*it1).j);

这里的判断条件写错了，不应该是两个都不相同才转移，（为啥经常犯这种低级错误呢？还特别难找）

改过之后

            if ((*it1).i != i || (*it1).j != j)
                dfs(count, (*it1).i, (*it1).j);

然后结果
在这里插入图片描述

为什么会这样呢？

再去审题就会发现一个想当然的地方

如果一头奶牛处在这个装置的起点或者终点，这头奶牛就必须使用这个装置。

还以为还是可以选择传送或者转移呢，原来是必须要传送啊

此时我又陷入了迷茫，必须要转移的话那是不是会导致一直循环转移啊？还是只能转移一次吗？

然后我无奈之下看了题解

为啥全是BFS（广度优先搜索）啊？？肯定是互相抄的结果，我偏不信邪，就要用DFS来写。

不过还是有收获的可以直接让那个转移，在本层转移

bool dfs(int count, int i, int j)
{
    if (place[i][j] == '=')
    {
        min_time = min(count, min_time);
        return true;
    }
    if (i > N || i < 1 || j > M || j < 1 || path[i][j] || place[i][j] == '#')
    {
        return false; // 不满足条件直接回溯
    }
    path[i][j] = true; // 初始化条件
    if (place[i][j] >= 'A' && place[i][j] <= 'Z')
    {
        list<struct point>::iterator it1 = transit[place[i][j]].begin();
        for (; it1 != transit[place[i][j]].end(); it1++)
        {
            if ((*it1).i != i || (*it1).j != j)
            {
                i = (*it1).i;
                j = (*it1).j;
                break;
            }
        }
    }
    dfs(count + 1, i + 1, j );
    dfs(count + 1, i - 1, j);
    dfs(count + 1, i, j - 1);
    dfs(count + 1, i, j + 1);
    path[i][j] = false; // 恢复状态
    return false;
}

这样不就好了

结果
在这里插入图片描述

为啥还是这样啊？还有WA的啊？

然后我又左思右想，是不是初始化的点不太对啊？回复状态的点也不太对啊？

确实是这样的，我们转移状态后恢复的状态应该是最一开始的点的状态，而不是那个传送点的状态。

至于为什么传送后的点的状态不用的初始化和恢复，因为这个点后边还可以转回来使用

bool dfs(int count, int i, int j)
{
    int init_i = i, init_j = j;
    if (place[i][j] == '=')
    {
        min_time = min(count, min_time);
        return true;
    }
    if (i > N || i < 1 || j > M || j < 1 || path[i][j] || place[i][j] == '#')
    {
        return false; // 不满足条件直接回溯
    }
    if (place[i][j] >= 'A' && place[i][j] <= 'Z')
    {
        list<struct point>::iterator it1 = transit[place[i][j]].begin();
        for (; it1 != transit[place[i][j]].end(); it1++)
        {
            if ((*it1).i != i || (*it1).j != j)
            {
                i = (*it1).i;
                j = (*it1).j;
                break;
            }
        }
    }
    path[init_i][init_j]=true;  
    if (i + 1 >= 1 && i + 1 <= N && j >= 1 && j <= M && !path[i + 1][j] && place[i + 1][j] != '#')
        dfs(count + 1, i + 1, j);
    if (i - 1 >= 1 && i - 1 <= N && j >= 1 && j <= M && !path[i - 1][j] && place[i - 1][j] != '#')
        dfs(count + 1, i - 1, j);
    if (i >= 1 && i <= N && j - 1 >= 1 && j - 1 <= M && !path[i][j - 1] && place[i][j - 1] != '#')
        dfs(count + 1, i, j - 1);
    if (i >= 1 && i <= N && j + 1 >= 1 && j + 1 <= M && !path[i][j + 1] && place[i][j + 1] != '#')
        dfs(count + 1, i, j + 1);
    path[init_i][init_j] = false; // 恢复状态
    return false;
}

我顺便还剪了剪枝

结果

在这里插入图片描述

唉无能为力的，只能放弃DFS了，而且再剪枝也减不了了，因为DFS进行了许多重复运算，要是

我会记忆深度优先搜索就好了，那样减少了重复运算没准就可以了。

然后只能转战BFS了

一不小心又出了个错 就是第47行多写的一个等于号，导致只对了37分，改过来后下全对

#include <bits/stdc++.h>
using namespace std;
int N, M;
struct point
{
    int i, j, c;
};
char place[301][301];
map<char, list<struct point> > transit;
bool path[301][301];
int min_time = 1 << 20;
int temp[4] = {1, 0, -1, 0};
int temp2[4] = {0, 1, 0, -1};
int start_i, start_j;
queue<point> q;

int bfs()
{
    q.push((struct point){start_i, start_j});
    struct point p;
    while (!q.empty())
    {
        p = q.front();
        q.pop();
        if (place[p.i][p.j] == '=')
        {
            return p.c;
        }
        if (place[p.i][p.j] >= 'A' && place[p.i][p.j] <= 'Z')
        {
            list<struct point>::iterator it1 = transit[place[p.i][p.j]].begin();
            for (; it1 != transit[place[p.i][p.j]].end(); it1++)
            {
                if ((*it1).i != p.i || (*it1).j != p.j)
                {
                    p.i = (*it1).i;
                    p.j = (*it1).j;
                    break;
                }
            }
        }
        for (int i = 0; i < 4; i++)
        {
            int x = p.i + temp[i], y = p.j + temp2[i];
            if (place[x][y] != '#' && !path[x][y] && x >= 1 && x <= N && y >= 1 && y <= M)
            {
                path[x][y] = true;
                q.push((point){x, y, p.c + 1});
            }
        }
    }
    return -1;
}
int main()
{
    cin >> N >> M;
    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= M; j++)
        {
            cin >> place[i][j];
            if (place[i][j] == '@')
            {
                start_i = i;
                start_j = j;
            }
            else if (place[i][j] >= 'A' && place[i][j] <= 'Z')
            {
                struct point p = {i, j, 0};
                transit[place[i][j]].push_back(p);
            }
        }
    }
    cout << bfs();
    return 0;
}

结果：

在这里插入图片描述

总结

这题不难考的就是审题和BFS的书写。

我主要就是老卡在一些审题和小细节的bug 上什么时候我才能养成不出小bug 的能力，和快速检查出bug的能力，其次就是审题要仔细一些，看清楚一些细节再写题。

Maze_广度优先搜索_
10-02
总结来说，"Maze_广度优先搜索_"是关于使用广度优先搜索算法解决迷宫路径问题的应用。通过理解BFS的基本原理和实现细节，我们可以编写代码来自动寻找从起点到终点的最短路径。提供的源代码和测试案例是实现这一功能...
洛谷 P1825 [USACO11OPEN]Corn Maze S
君义NOIP的博客
03-03 682
从起点出发进行广搜，把位置及到该位置的步数打包成一个结点，队列中保存这样的结点。每出队一个结点，访问该结点位置上下左右的四个位置，该位置必须同时满足条件：在地图内、未访问过、不是墙。如果满足条件，则访问该位置，到该位置的步数加1，把该位置和步数打包成结点入队。在广搜时，如果从当前位置出发走一步到达的位置是传送门，则正常进行，将该位置标记为已访问，打包该位置和步数成一个结点，结点入队。当出队的位置是传送门时，让牛从当前所在传送门的位置传送到另一个门的位置，从这里开始继续走。，表示一个传送门的位置。
洛谷P1825 [USACO11OPEN]Corn Maze S O（1）查找另一个传送门
l3_8alc的博客
07-31 267
利用pair二维数组，实现O(1)查找传送门
洛谷 P1825
qq_45621367的博客
10-07 278
题目链接 题目大意 给出一个n*m的矩阵，里面包含了起点位置和终点位置和所有传送门的位置，现在有一头牛在起点，他可以往上下左右四个方向行动，每行动一格将花费一个单位的时间，使用传送门不需要时间(传送门用大写字母A~W表示)，传送门以一对的形式存在。最后就是输出从起点到终点所花费的最小时间。 解题思路 首先明确，这是一道广搜的题目，因为只用找一条从起点到终点的用时最短路。那么我们来考虑一下，本道题和普通的广搜迷宫有什么不同。显而易见，唯一的不同就是多了一堆双向传送的传送门，所以我们只要在输入的时候记录一下每一
洛谷p1825
weixin_60708377的博客
01-16 242
分析： 求的是最短时间，我们用bfs。 分析题目：本来是个简单的搜索题，但是有个传送门，我们要处理一下，传送门的性质是把点送到相应的点去，所以如果下一个点是传送门，我们可以直接把传送门对面的点放入队列中。 #include<stdio.h> struct point { //坐标 int x; int y; //步数 int step; }; struct point queue[100000000];//队列 int end;//队尾 int M,N; //地图大小
洛谷——p1825 Corn Maze
明里灰的博客
01-01 428
去年秋天，农夫约翰带着奶牛参观了一个玉米迷宫。但这不是普通的玉米迷宫：它有几个重力驱动的传送滑梯，可以让奶牛从迷宫中的一个点瞬间传送到另一个点。滑梯是双向工作的：一头牛可以从滑梯的起点瞬间滑到终点，或者从终点滑到起点。如果一头牛踩在滑梯两端的空间上，她必须使用滑梯。玉米迷宫的外面除了一个出口，全是玉米。迷宫可以用一个N x M表示。 玉米，#表示，这些格子是不可以通过的。 草地，.表示，可以简单的通过。 传送装置，每一对大写字母 A到 Z表示。 出口，=表示。 起点，@表示
C语言使用广度优先搜索算法解决迷宫问题（队列）
08-29
C语言使用广度优先搜索算法解决迷宫问题（队列） 本文主要介绍了C语言使用广度优先搜索算法解决迷宫问题的相关知识点，详细解释了C语言队列广度优先搜索算法的使用技巧和实现细节。 一、广度优先搜索算法的基本...
基于Python实现蚁群算法与广度优先搜索求解迷宫最优路径问题源码+exe可执行程序(直接运行).zip
08-09
基于Python实现蚁群算法与广度优先搜索求解迷宫最优路径问题源码+exe可执行程序(直接运行).zip 【项目介绍】 该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 本项目适合计算机...
EBMR.rar_广度优先
09-14
本话题主要涉及"广度优先搜索(Breadth-First Search, BFS)"这一经典算法，该算法常用于寻找图或树中两点之间的最短路径。在迷宫问题中，BFS能够有效地找到从起点到终点的最短路径。 首先，我们来看"7maze.cpp"这个...
迷宫广度优先搜索算法java源码.docx
05-27
### 迷宫广度优先搜索算法Java源码解析 #### 一、背景介绍 本文档主要介绍了使用Java语言实现的迷宫广度优先搜索（Breadth-First Search，简称BFS）算法。该算法应用于解决迷宫问题，即在一个由单元格组成的迷宫中...
洛谷P1825
陈颜的博客
06-24 5076
题目链接 一个BFS，虽然洛谷难度标签是提高，但是感觉还行。 很熟悉的传送门，比较特殊的地方是需要剪枝（可能是因为我题目刷少了，还没遇到过BFS剪枝 AC代码： /* * @Author: hesorchen * @Date: 2020-04-14 10:33:26 * @LastEditTime: 2020-06-24 23:36:50 * @Link: https://hesorchen.github.io/ */ #include <map> #include <set&g
洛谷 P1825 [USACO11OPEN]玉米田迷宫Corn Maze
faojie的博客
07-25 977
洛谷 P1825 [USACO11OPEN]玉米田迷宫Corn Maze题目题目描述This past fall, Farmer John took the cows to visit a corn maze. But this wasn’t just any corn maze: it featured several gravity-powered teleporter slides, whic
洛谷搜索题单（BFS/DFS）13道题总结
qq_38702697的博客
07-25 1896
洛谷搜索题单（BFS/DFS）13道题总结 P1219 八皇后 经典深搜问题，本题的难点在于如何判断斜线上是否已有棋子，可使用数学中斜率和截距来判断是否是在同一条直线上。 P2392 kkksc03考前临时抱佛脚 深搜问题，但本题又是01背包问题，把作业分别放进左脑和右脑，最后去左脑和右脑的最大值就是该课的最终结果，一开始想得太复杂了，想把左脑和右脑一起处理。因此应该将搜索简单化，编写代码时尽量简化状态 背包容量相当于t/2,最好的结果当然是t/2，意味着左脑和右脑之间没有时间差，即求时间差尽量小，单脑时间
洛谷 P1361 小M的作物
yzyyylx的博客
02-22 562
题面题意 有n个作物,A,B两块地,将它们种在A,B中的一块,每个作物种在两块地上分别有一个收益,有m种组合,若这个组合内的作物都在一块地内则有额外收益,求最大收益. 做法 这题与洛谷 P3355 骑士共存问题有些相似,都是转化为最小割的问题. 首先假设每种作物均有两个,分别种在A,B上,现在要每种作物都要拔掉一个,那么在跑最大流时,有流量则代表这种做法不采用,最后用总收益减去最大流量
洛谷1879 [USACO06NOV]玉米田Corn Fields
iwi
12-12 377
题目：Corn Fields 思路：记忆化搜索+位运算 。 代码：#include #include #include #include #include #include #include #include #include using namespace std; long long m,n; long long b[5000]= {0}; long l
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5172
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
PCA（主成分分析）算法的应用场景
最新发布
huanfeng_AI的博客
11-09 150
需要注意的是，PCA并不适用于所有场景。例如，当数据之间存在非线性关系时，PCA可能无法完全揭示数据的内在结构。此外，PCA对初始变量的顺序和标签敏感，不同的变量顺序可能导致不同的主成分结果。因此，在选择数据分析方法时，需要根据具体的数据和任务需求来决定是否使用PCA。
STL set
hls0611的博客
11-09 108
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
Java实现AI迷宫搜索算法深度与广度优先搜索解析
该项目提供了多种迷宫搜索方法的实现，包括深度优先搜索（Depth First Search，DFS）、广度优先搜索（Breadth First Search，BFS）以及其他搜索算法，例如A*搜索算法（ASTAR）。项目包含了多个Java类文件，它们负责...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值