搜索问题(不带权值的BFS)_小明系列故事——捉迷藏

最新推荐文章于 2022-01-22 16:53:58 发布
最新推荐文章于 2022-01-22 16:53:58 发布
阅读量417 收藏
点赞数
分类专栏： 图论之搜索问题模板 文章标签： 为AC而战 为时间而战 为空间而战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZJWSA/article/details/81414594
版权

Title：

小明的妈妈生了三个孩子，老大叫大明， 老二叫二明， 老三...， 老三自然就叫小明了。
　　一天，小明的妈妈带小明兄弟三人去公园玩耍，公园里面树木很多，有很多地方可以藏身， 于是他们决定玩捉迷藏。经过几轮的猜拳后，第一轮是小明来找其他两个人，游戏规则很简单：
　　只要小明可以在规定的时间内找到他们就算小明获胜，并且被发现的两个人猜拳决定谁在下一轮负责找人；如果在规定的时间内只找到一个人，那么没有被发现的人获胜，被找到的人下一轮负责找人；如果在规定的时间内一个人都没有找到，则小明失败了，下一轮还是他来找人。现在小明想知道，在规定时间内，自己是否可以找到所有的人，现在他想请你来帮忙计算一下。
　　为了简单起见，把公园看成是n行m列的矩阵，其中’S’表示小明，’D’表示大名，’E’表示二明，’X’表示障碍物，’.’表示通路。这里，我们把发现定义为，可以直接看到对方， 也就是说两个人在同一行或者同一列，并且中间没有障碍物或者没有其他人就可以看到对方。并且假设，大明，二明藏好以后就不会再改变位置，小明每个单位时间可以从当前的位置走到相邻的四个位置之一，并且不会走出公园。

Input

测试数据第一行是一个正整数T，表示有T组测试数据。
每一组测试数据首先是三个正整数n,m,t，分别表示行数、列数和规定的时间，接下来n行，每行m个上述的字符，并且保证有且只有一个’S’，一个’E’，一个’D’。

[Technical Specification]
T < 200
3 <= n, m <= 100
0 <= t <= 100

Output

每组先输出一行Case c:(c表示当前的组数，从1开始计数)；
接下来一行，如果小明可以在规定时间内找到所有的人，则输出最少需要的时间，否则输出-1。

Sample Input

3 
5 6 3 
XXD... 
....E. 
....X. 
....S. 
...... 
5 6 3 
XDX...
....E. 
...... 
....S. 
...... 
5 6 8 
XXDX.. 
.XEX.. 
...... 
....S. 
......

Sample Output

Case 1: 
-1 
Case 2: 
3 
Case 3: 
-1

 思路：

 单纯的搜索题目，这道题目让我加深对优先队列和队列的区别。

那开始考虑是不是还有更好的思路可以考虑，先整理思路的过程，AC之路。

第一种（AC之战）：S找E，D。四维数组标记，可以AC。

第二种（时间之战）：用三维数组对于地图，预处理一下。E，D先对于自己进行处理一下，把可以看到自己的路径标记为1，看不到的为0.

                  一来：每一次都要查看寻找四周的时间，节约了（耗时非常高的点）。

                  二来：节约了许多的调用函数代码（耗时点二）。

第三种（空间之战）：从地图出发，前面两个都是在数组标记方面节约时间，现在我直接从根本入手。地图出发。相邻用*，其余用D,E。

                  主要改变在第二种的基础上面，节约了空间（但是时间好像长了一点，不过思路可以。哎）。

AC之战：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
using namespace std;

struct node
{
    int x,y,step;
    int e,d;
};

int si,sj;
char Map[205][205];
bool vis[3][3][205][205];
int fx[]= {0,0,1,-1},fy[]= {-1,1,0,0},n,m,Time;


void Search(node &p)
{
    for(int i = p.x - 1; i >= 0; i--)
    {
        if(Map[i][p.y] == 'D' )
        {
            p.d = 1;
            break;
        }
        else if(Map[i][p.y] == 'E')
        {
            p.e = 1;
            break;
        }
        else if(Map[i][p.y] == 'X') break;
    }
    for(int i = p.x + 1; i < n; i++)
    {
        if(Map[i][p.y] == 'D')
        {
            p.d = 1;
            break;
        }
        else if(Map[i][p.y] == 'E')
        {
            p.e = 1;
            break;
        }
        else if(Map[i][p.y] == 'X') break;
    }

    for(int i = p.y - 1; i >= 0; i--)
    {
        if(Map[p.x][i] == 'D')
        {
            p.d = 1;
            break;
        }
        else if(Map[p.x][i] == 'E')
        {
            p.e = 1;
            break;
        }
        else if(Map[p.x][i] == 'X') break;
    }
    for(int i = p.y + 1; i < m; i++)
    {
        if(Map[p.x][i] == 'D')
        {
            p.d = 1;
            break;
        }
        else if(Map[p.x][i] == 'E')
        {
            p.e = 1;
            break;
        }
        else if(Map[p.x][i] == 'X') break;
    }
}

int bfs()
{
    node s,p;
    queue<node> q;
    s.x = si;
    s.y = sj;
    s.step = s.e = s.d = 0;
    vis[0][0][s.x][s.y] = 1;
    q.push(s);
    while(!q.empty())
    {
        s = p = q.front();
        q.pop();
        Search(p);
        if( p.e == 1 && p.d == 1)
            return p.step;
        for(int i=0; i<4; i++)
        {
            s.x = fx[i] + p.x;
            s.y = fy[i] + p.y;
            s.step = p.step +1;
            s.e = p.e;
            s.d = p.d;
            if(s.x>=0 && s.x<n && s.y>=0 && s.y<m && s.step <= Time &&
                    Map[s.x][s.y]=='.' && !vis[s.e][s.d][s.x][s.y])
            {
                vis[s.e][s.d][s.x][s.y] = 1;
                q.push(s);
            }
        }
    }
    return -1;
}

int main()
{
    int T;
    scanf("%d",&T);
    for(int l=1; l<=T; l++)
    {
        memset(vis,0,sizeof(vis));
        scanf("%d%d%d",&n,&m,&Time);
        for(int i=0; i<n; i++)
        {
            scanf("%s",&Map[i]);
            for(int j=0; j<m; j++)
            {
                if(Map[i][j] == 'S')
                {
                    si = i;
                    sj = j;
                    Map[i][j] = '.';
                }
            }
        }
        printf("Case %d:\n%d\n",l,bfs());
    }
    return 0;
}

时间之战：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>

using namespace std;

int x,y,z,si,sj,ei,ej,di,dj;
char mp[105][105];
int vis[2][105][105],sign[2][2][105][105];
int fx[]={0,0,-1,1},fy[]={-1,1,0,0};

struct node
{
    int x,y,step;
    bool e,d;
public:
    node(){}
    node(int xx,int yy,int sstep,bool ee,bool dd)
    {
        x = xx;y=yy;step=sstep;e=ee;d=dd;
    }
};


void look(node &p)
{
    if(vis[0][p.x][p.y]) p.e = 1;
    if(vis[1][p.x][p.y]) p.d = 1;
}


int bfs()
{
    struct node s,p;
    s.x = si;
    s.y = sj;
    s.step = 0;
    s.e = vis[0][s.x][s.y];
    s.d = vis[1][s.x][s.y];
    sign[s.e][s.d][s.x][s.y] = 1;
    queue<node> q;
    q.push(s);
    while(!q.empty())
    {
        p = q.front();
        q.pop();
        look(p);
        if(p.e && p.d)
            return p.step;
        for(int i=0;i<4;i++)
        {
            node k = node( p.x + fx[i] ,p.y + fy[i] ,p.step + 1, p.e, p.d );
            if(k.x>=0 && k.x<x && k.y>=0 && k.y<y && mp[k.x][k.y] == '.' && !sign[k.e][k.d][k.x][k.y] && k.step <=z)
            {
                sign[k.e][k.d][k.x][k.y] = 1;
                q.push(k);
            }
        }

    }
    return -1;
}


void Search(int px,int py,int flag)
{
     ///向上
     for(int i=px-1;i>=0;i--)
     {
         if(mp[i][py] == '.')
             vis[flag][i][py] =1;
         else break;
     }
     ///向下
     for(int i=px+1;i<x;i++)
     {
         if(mp[i][py] == '.')
            vis[flag][i][py] =1;
         else break;
     }
     ///向左
     for(int i=py-1;i>=0;i--)
     {
         if(mp[px][i] == '.')
            vis[flag][px][i] = 1;
         else break;
     }
     ///向右
     for(int i=py+1;i<y;i++)
     {
         if(mp[px][i] == '.')
            vis[flag][px][i] = 1;
         else break;
     }
}

int main()
{
    int T;
    scanf("%d",&T);
    for(int l=1;l<=T;l++)
    {
        scanf("%d%d%d",&x,&y,&z);
        for(int i=0;i<x;i++)
        {
            scanf("%s",&mp[i]);
            for(int j=0;j<y;j++)
            {
                if(mp[i][j] == 'S')
                { si = i;sj = j;mp[i][j]='.';}
                else if(mp[i][j] == 'D')
                { di = i;dj =j;}
                else if(mp[i][j] == 'E')
                { ei = i;ej = j;}
            }
        }
        memset(vis,0,sizeof(vis));
        memset(sign,0,sizeof(sign));
        Search(ei,ej,0);
        Search(di,dj,1);
        printf("Case %d:\n%d\n",l,bfs());
    }
    return 0;
}

空间之战：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>

using namespace std;

int x,y,z,si,sj,ei,ej,di,dj;
char mp[105][105];
int sign[2][2][105][105];
int fx[]={0,0,-1,1},fy[]={-1,1,0,0};

struct node
{
    int x,y,step;
    bool e,d;
public:
    node(){}
    node(int xx,int yy,int sstep,bool ee,bool dd)
    {
        x = xx;y=yy;step=sstep;e=ee;d=dd;
    }
};

bool border(int dx,int dy)
{
    if(dx<0 || dx >=x || dy<0 || dy>=y || mp[dx][dy] == 'X')
        return false;
    if(dx == ei && dy == ej)
        return false;
    if(dx == di && dy == dj)
        return false;
    return true;
}

void look(node &p)
{
    if(mp[p.x][p.y] == '*')
        p.e = p.d = 1;
    else if(mp[p.x][p.y] == 'E')
        p.e = 1;
    else if(mp[p.x][p.y] == 'D')
        p.d = 1;
}


int bfs()
{
    struct node s,p;
    s.x = si;
    s.y = sj;
    s.step = 0;
    s.e = s.d = 0;
    look(s);
    sign[s.e][s.d][s.x][s.y] = 1;
    queue<node> q;
    q.push(s);
    while(!q.empty())
    {
        p = q.front();
        q.pop();
        look(p);
        if(p.e && p.d)
            return p.step;
        for(int i=0;i<4;i++)
        {
            node k = node( p.x + fx[i] ,p.y + fy[i] ,p.step + 1, p.e, p.d );
            if(k.x && !sign[k.e][k.d][k.x][k.y] && k.step <=z)
            {
                sign[k.e][k.d][k.x][k.y] = 1;
                q.push(k);
            }
        }

    }
    return -1;
}


void Search(int px,int py,char ch,int kx,int ky,char ch2)
{
     ///向上
     for(int i=px-1;i>=0;i--)
     {
         if(mp[i][py] == 'X' || i==kx && py == ky)
            break;
         if(mp[i][py] == '.')
             mp[i][py] = ch;
         else if(mp[i][py] == ch2)
             mp[i][py] = '*';
     }
     ///向下
     for(int i=px+1;i<x;i++)
     {
         if(mp[i][py] == 'X' || i==kx && py == ky)
            break;
         if(mp[i][py] == '.')
             mp[i][py] = ch;
         else if(mp[i][py] == ch2)
             mp[i][py] = '*';
     }
     ///向左
     for(int i=py-1;i>=0;i--)
     {
         if(mp[px][i] == 'X' || px==kx && i == ky)
            break;
         if(mp[px][i] == '.')
             mp[px][i] = ch;
         else if(mp[px][i] == ch2)
             mp[px][i] = '*';
     }
     ///向右
     for(int i=py+1;i<y;i++)
     {
         if(mp[px][i] == 'X' || px==kx && i == ky)
            break;
         if(mp[px][i] == '.')
             mp[px][i] = ch;
         else if(mp[px][i] == ch2)
             mp[px][i] = '*';
     }
}

int main()
{
    int T;
    scanf("%d",&T);
    for(int l=1;l<=T;l++)
    {
        scanf("%d%d%d",&x,&y,&z);
        for(int i=0;i<x;i++)
        {
            scanf("%s",&mp[i]);
            for(int j=0;j<y;j++)
            {
                if(mp[i][j] == 'S')
                { si = i;sj = j;mp[i][j]='.';}
                else if(mp[i][j] == 'D')
                { di = i;dj =j;}
                else if(mp[i][j] == 'E')
                { ei = i;ej = j;}
            }
        }
        memset(sign,0,sizeof(sign));
        Search(ei,ej,'D',di,dj,'E');
        Search(di,dj,'E',ei,ej,'D');
        printf("Case %d:\n%d\n",l,bfs());
    }
    return 0;
}

 

让你一生残梦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【蓝桥杯选拔赛真题39】Scratch捉迷藏 少儿编程scratch蓝桥杯省赛真题讲解
青少年编程学习指导
03-18 1407
scratch捉迷藏 一、题目要求 小猫和它的小伙伴在郊外饱餐后，小猫提出：“不如我们玩捉迷藏吧！你们 快藏好，我来找你们！” 1、编程实现 按下鼠标，拖拽角色（螃蟹、企鹅、小猴）移动到任意位置后，松开鼠标角 色消失。当三个小伙伴都藏起来以后，小猫说：“我要来找你们了！”。 点击绿旗，小伙伴们出现在舞台下边界处 按下鼠标，拖拽角色（螃蟹、企鹅、小猴）移动到舞台的任意位置后 松开鼠标角色消失 螃蟹、企鹅、小猴全部藏好后，小猫说：“我要来找你们了！” ..
图片隐写题解第二弹
huster0828的博客
11-18 957
1.this_is_flag(from攻防世界) 这道题没有附件，这道题就是在题目中的！ 2.give_you_flag(from攻防世界) 里面有一个gif，在后面闪过了一个二维码，然后用stegsolve->Analyse->Frame Browser就能看到一帧一帧的图片啦，然后就找到了一个二维码 可是缺二维码定位的东西，所以我们要把他P上 ...
小学生c++趣味编程入门视频教程 少儿C十十信息学奥赛竞赛网课
04-24
这是一套符合小学生认知特点的C++编程入门视频教程。以程序为中心，适当地弱化语法，注重算法。利用流程图清思路，激发学习兴趣，培养计算思维。适用人群：小学四年级以上的中小学孩子          C++初学者本课程是基于小学生的认知发展水平开展教学的，浅显易懂。用编程的方式实现小学生日常生活和学习中遇到的例子，能激发孩子学习编程的兴趣。学完本课程后，孩子能编写简单的代码，用程序解决生活及学习中遇到的一些题目，也看懂一般的C++代码，学会编程的方法去思考和解决问题。本课程共83节课时，每节课十几分钟，每节课都有编程实例和课后练习，在讲新的课时之前，老师都会把上节课留的练习进行分析讲解。购买本视频教程后，赠送的资料包括课程配套教学文档和源码，入群有老师提供在线解答学习中遇到的问题。
HDU 4528 小明系列故事——捉迷藏 bfs
bibibi724
02-23 393
小明的妈妈生了三个孩子，老大叫大明， 老二叫二明， 老三...， 老三自然就叫小明了。 　　一天，小明的妈妈带小明兄弟三人去公园玩耍，公园里面树木很多，有很多地方可以藏身， 于是他们决定玩捉迷藏。经过几轮的猜拳后，第一轮是小明来找其他两个人，游戏规则很简单： 　　只要小明可以在规定的时间内找到他们就算小明获胜，并且被发现的两个人猜拳决定谁在下一轮负责找人；如果在规定的时间内只找到一个人，那么没有被...
hdu4528小明系列故事——捉迷藏(bfs)
ophunter的专栏
07-18 1170
小明系列故事——捉迷藏 Time Limit: 500/200 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 609    Accepted Submission(s): 141 Problem Description 　　小明的妈妈生了三个孩子，老大叫大
小明的故事
djr2ss666666的博客
03-19 309
wf.rar_MATLAB编程_权值训练_神经网络 权值_神经网络权值
07-15
本教程通过一系列MATLAB脚本文件（.m文件）演示了如何进行神经网络的权值训练。 `wf.rar` 包含的MATLAB代码可能是一个完整的神经网络训练示例，由多个步骤组成，如初始化、前向传播、反向传播和权重更新。这些脚本...
weight_fusion_exp.rar_加权算法_最优加权算法_最优加权融合_权值 融合_权值融合
07-14
在标题"weight_fusion_exp.rar_加权算法_最优加权算法_最优加权融合_权值融合_权值融合"中，我们可以看到这个压缩包可能包含了一个关于加权融合算法的实验或实例，特别是关于寻找最优权值分配的探讨。 加权算法的...
BPNNPID.rar_BP神经网络_BackPropagation_pid 梯度下降_权值修正_梯度下降
07-15
然而，传统的PID控制器参数整定往往依赖于经验或试错法，效率较低且可能不理想。BP神经网络则可以通过学习和调整其内部权重来模拟复杂的非线性关系，从而实现对PID参数的优化整定。 4-5-3型的BP网络结构指的是网络...
lizilvbo.zip_信息融合 matlab_权值融合_离散粒子滤波_运动状态估计_运动颜色
09-19
在IT领域，特别是计算机视觉和智能系统中，信息融合、权值融合以及粒子滤波等技术扮演着重要的角色。本文将深入探讨标题和描述中提到的几个关键知识点，并结合压缩包内的`lizilvbo.m`文件，来阐述如何在MATLAB环境下...
卷积神经网络.rar_卷积神经_卷积神经网络_卷积网络_权值更新_神经网络 目标
07-15
建立卷积神经网络；使用训练样本对卷积神经网络进行训练；使用测试样本对卷积神经网络进行测试；卷积神经网络的前向计算过程；计算目标函数值，以及目标函数对权值和偏置的偏导数；更新网络的权值和偏置。
不同权值的bfs问题
纵无涯
12-12 366
不同权值的bfs问题 题目链接 解题思路: 多权bfs可以用优先队列优化以保证每一步都队列中取出的每一步都是最优解，但本题飞机和步行两种方式，先选飞行再选步行可以保证每步采取最优情况。 首先分析状态，可开三维vis数组，vis[x][y][kepp]表示走到(x,y)坐标可以继续续航keep时间所走的步数，由于降落后便可以是空地所以可以贪心飞行。 注意：搜索起点可能无法起飞，搜索终点无法降落等各种...
HUST 1619 小明的细胞
Tyshawn的博客
12-01 392
小明的细胞 时间限制：1秒 内存限制：128兆 414 次提交 105 次通过 题目描述 小明是一个喜欢思考的少年，他喜欢科学，有一天他做实验发现有一种奇怪的细胞，这种细胞新生以后第一分钟分裂产生一个新细胞，第二分钟产生两个新细胞，第三分钟产生3个新细胞，以此类推，到第五分钟分裂出5个新细胞，然后他就死亡了。小明想知道如果一开始有一个新生细胞，那么第N分钟到底有多少细胞。
HDU 4528 小明系列故事――捉迷藏 (很好的BFS)
Neutralzz的博客
07-30 676
在用BFS的时候可访问的点要用四个状态去记录，0代表一个都没找到，1代表找到了大明，2代表找到了二明，3代表都找到。 因为在BFS的过程中访问各节点时，因为访问时的状态不同，所以过程中包含有回路。 我的代码： #include #include #include #include using namespace std; const int maxn = 105; struct
第十三届蓝桥杯模拟赛——第8题
qq_57657120的博客
01-22 2837
问题描述 n 个小朋友正在做一个游戏，每个人要分享一个自己的小秘密。 每个小朋友都有一个 1 到 n 的编号，编号不重复。 为了让这个游戏更有趣，老师给每个小朋友发了一张卡片，上面有一个 1 到 n 的数字，每个数字正好出现一次。 每个小朋友都将自己的秘密写在纸上，然后根据老师发的卡片上的数字将秘密传递给对应编号的小朋友。如果老师发给自己的数字正好是自己的编号，这个秘密就留在自己手里。 小朋友们拿到其他人的秘密后会记下这个秘密，老师会再指挥所有小朋友将手中的秘密继续传递，仍然根据老师发的卡片上的数字将秘密.
HDU4528 小明系列故事——捉迷藏(BFS)
riba2534的博客
03-23 464
Problem Description 　小明的妈妈生了三个孩子，老大叫大明， 老二叫二明， 老三…， 老三自然就叫小明了。 　　一天，小明的妈妈带小明兄弟三人去公园玩耍，公园里面树木很多，有很多地方可以藏身， 于是他们决定玩捉迷藏。经过几轮的猜拳后，第一轮是小明来找其他两个人，游戏规则很简单： 　　只要小明可以在规定的时间内找到他们就算小明获胜，并且被发现的两个人猜拳决...
小明系列故事——捉迷藏
qq_41071646的博客
04-07 216
点击打开链接这个题让我发现了我的一个缺点 就是看见搜索题走不动 真心想ac 因为我自己的bfs dfs 自我感觉学的还可以 然后就一直wa这道题 最后和我学长交流的时候我才知道这个题没那么简单 因为 这个搜索并不是搜过之后就不再搜了 他还可以再继续搜索的 然后这个点是最最坑的  我学长洋洋洒洒的写了2000多行 大概思路就是先让被搜索的点先走 然后记录步数 然后再具体怎么处理 我倒是 不怎么清楚 ...
avif-0.5.0-cp37-cp37m-manylinux2010_i686.whl
07-27
python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！ python库，可以直接安装使用，再也不怕自己pip下载，出现等待超时的现象。欢迎下载使用，使用过程中如有使用问题，请及时与我沟通交流，帮你解决！
[毕设]HTTP代理服务器开发与实现.zip
最新发布
07-27
[毕设]HTTP代理服务器开发与实现
BFS演示：从V1到V3的最短路径与搜索算法详解
BFS适用于求解最短路径问题，特别是在无向图中，每条边的权值都相等，如题目给出的示例中，边权均为1。 搜索算法是解决问题的关键策略，分为两类：盲目搜索和启发式搜索。盲目搜索不利用任何关于问题结构的信息，只...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值