牛牛走迷宫-NC21583（优化搜索）

于 2021-09-23 00:04:55 发布
阅读量205 收藏
点赞数
分类专栏： 搜索 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57006708/article/details/120425647
版权

牛牛走迷宫

题号：NC21583
时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 32768K，其他语言65536K
64bit IO Format: %lld

题目描述 

有一个矩形迷宫(1 ≤ n,m ≤ 50)
` #`表示墙 `.`表示空地
起点(r1,c1)终点(r2,c2)
每一步可以采取下面策略之一

- 花费1秒的时间走向相邻的空地
- 花费2秒的时间传送到四个基本方向最近的空地

最少需要几秒能从起点到达终点 如果不能输出-1

输入描述:

第一行输入两个整数n,m (1 ≤ n,m ≤ 50)

接下来n行每行m个字符表示迷宫

接下来一行四个整数r1,c1,r2,c2分别表示起点与终点

输出描述:

输出一个整数

示例1

输入

复制

4 4
.##.
.###
.###
....
0 0 3 3

输出

复制

4

示例2

输入

复制

7 6
......
#####.
#.###.
#####.
#.###.
#####.
#.....
0 0 6 1

输出

复制

5

备注:

30%的数据：n,m<=10

另外30%的数据：n,m<=40

另外40%的数据：n,m<=50
/*
*@Author:   GuoJinlong
*@Language: C++
*/
//#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<list>
#include<set>
#include<iomanip>
#include<cstring>
#include<cctype>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<cassert>
#include<sstream>
#include<algorithm>
using namespace std;
const int mod=1e9+7;
typedef long long  ll;
#define ls (rt<<1)
#define rs (rt<<1|1)
#define mid (l+r)/2
#define mms(x, y) memset(x, y, sizeof x)
#define over(i,s,t) for(register long long i=s;i<=t;++i)
#define lver(i,t,s) for(register long long i=t;i>=s;--i)
const int MAXN = 305;
const int INF = 0x3f3f3f3f;
const int N=5e4+7;
const int maxn=1e5+5;
const double EPS=1e-10;
const double Pi=3.1415926535897;
//inline double max(double a,double b){
//    return a>b?a:b;
//}
//inline double min(double a,double b){
//    return a<b?a:b;
//}
 
int xd[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int yd[8] = {1, 0, -1, 0, -1, 1, -1, 1};
 
//void Fire(){
//    queue<node> p;
//    p.push({fx,fy,0});
//    memset(fire, -1, sizeof(fire));
//    fire[fx][fy]=0;
//    while(!p.empty()){
//        node temp=p.front();
//        p.pop();
//        for(int i=0;i<8;i++){
//            int x=temp.x+xd[i];
//            int y=temp.y+yd[i];
//            if(x<0||x>=n||y<0||y>=m||fire[x][y]!=-1){
//                continue;
//            }
//            fire[x][y]=temp.val+1;
//            p.push({x,y,temp.val+1});
//        }
//    }
//}
//int bfs(){
//    queue<node> p;
//    memset(vis, 0, sizeof(vis));
//    p.push({sx,sy,0});
//    while (!p.empty()) {
//        node temp=p.front();
//        vis[temp.x][temp.y]=1;
//        p.pop();
//        for(int i=0;i<4;i++){
//            int x=temp.x+xd[i];
//            int y=temp.y+yd[i];
//            if(x<0||x>=n||y<0||y>=m)  continue;
//            if(x==ex&&y==ey&&temp.val+1<=fire[x][y]) return temp.val+1;
//            if(vis[x][y]||temp.val+1>=fire[x][y]||a[x][y]=='#') continue;
//            p.push({x,y,temp.val+1});
//        }
//    }
//    return -1;
//}

//一维哈希
//int n;
//string s;
//int bas=131;
//typedef unsigned long long ull;
//const ull mod1=100001651;
//ull a[100010];
//ull Hash(string s){
//    ll ans=0;
//    for(int i=0;i<s.size();i++){
//        ans*=bas;
//        ans+=int(s[i]);
//        ans%=mod1;
//    }
//    return ans;
//}

//二维哈希
//using lom=unsigned long long ;
//const lom bas1=131,bas2=233;
//const int M=505;
//int n,m;
//char a[M][M];
//lom _hash[M][M];
//lom p1[M],p2[M];
//
//
//void init(){
//    p1[0]=1;
//    p2[0]=1;
//    for(int i=1;i<=505;i++){
//        p1[i]=p1[i-1]*bas1;
//        p2[i]=p2[i-1]*bas2;
//
//    }
//}
//void Hash(){
//    _hash[0][0]=_hash[0][1]=_hash[1][0]=0;
//    for(int i=1;i<=n;i++){    //前缀和
//        for(int j=1;j<=m;j++){
//            _hash[i][j]=_hash[i][j-1]*bas1+a[i][j]-'a';
//        }
//    }
//    for(int i=1;i<=n;i++){   //二维前缀和
//        for(int j=1;j<=m;j++){
//            _hash[i][j]+=_hash[i-1][j]*bas2;
//        }
//    }
//
//}


//int pre[1010];
//int in[1010];
//int post[1010];
//int k;
//struct node{
//    int value;
//    node *l,*r;
//    node (int value=0,node *l=NULL,node *r=NULL):value(value),l(l),r(r){}
//};
//void builttree(int l,int r,int &t,node * &root){
//    int flag=-1;
//    for(int i=l;i<=r;i++){
//        if(in[i]==pre[t]){
//            flag=i;
//            break;
//        }
//    }
//    if(flag==-1) return;
//    root=new node(in[flag]);
//    t++;
//    if(flag>l) builttree(l,flag-1,t,root->l);
//    if(flag<r) builttree(flag+1,r,t,root->r);
//
//}
//void preorder(node *root){
//    if(root!=NULL)
//    {
//        post[k++]=root->value;
//        preorder(root->l);
//        preorder(root->r);
//
//    }
//}
//void inorder(node *root){
//    if(root!=NULL)
//    {
//        inorder(root->l);
//        post[k++]=root->value;
//        inorder(root->r);
//
//    }
//}
//void postorder(node *root){
//    if(root!=NULL)
//    {
//        postorder(root->l);
//        postorder(root->r);
//        post[k++]=root->value;
//    }
//}

//线段树
//#define MAX 1000000
//int tree[MAX<<2];
//void pushup(int rt){
//    tree[rt]=tree[rt<<1]+tree[rt<<1|1];
//}
//void update(int rt,int i,int val,int l,int r)
//{
//    if(r==l) {
//        tree[rt]+=val;
//        return;
//    }
//    if(i<=mid){
//        update(ls,i,val,l,mid);
//    }
//    else {
//        update(rs,i,val,mid+1,r);
//    }
//    pushup(rt);
//}
//int query(int rt,int l,int r,int k){
//    if(l==r) return l;
//    if(tree[rt<<1|1]>=k)
//        return query(rs,mid+1,r,k);
//    else return query(ls,l,mid,k-tree[rt<<1|1]);
//}


//二维树状数组
//int lowbit(int x){
//    return x&(-x);
//}
//void updata(int x,int y,int c)
//{
//    for(int i=x;i<=n;i+=lowbit(i)){
//        for(int j=y;j<=n;j+=lowbit(j)){
//            sum[i][j]+=c;
//        }
//    }
//}
//int getsum(int x,int y){
//    int ans=0;
//    for(int i=x;i>0;i-=lowbit(i)){
//        for(int j=y;j>0;j-=lowbit(j)){
//            ans+=sum[i][j];
//        }
//    }
//    return ans;
//}

int n,m;
int ex,ey;
char a[110][110];
struct node {
    int x,y,t;
     friend bool operator <(const node &a,const node & b){ //优先队列的优先比较
        return a.t>b.t;
    }
};
int check(int x,int y){
    if(x<0||x>=n||y<0||y>=m) return false;
    return true;
}
int bfs(int x,int y){
    priority_queue<node>p;
    p.push({x,y,0});
    while (!p.empty()) {
        node tmp=p.top();
        p.pop();
        int xx=tmp.x;
        int yy=tmp.y;
        int t=tmp.t;
        if(xx==ex&&yy==ey){
            return t;
        }
        for(int i=0;i<4;i++){
            int x=xx+xd[i];
            int y=yy+yd[i];
            if(check(x,y)&&a[x][y]!='#'&&a[x][y]!='*'){
                a[x][y]='*'; //防止回去
                p.push({x,y,t+1});
            }
            while (check(x,y)&&a[x][y]=='#') { //沿着同一方向前进
                x+=xd[i];
                y+=yd[i];
            }
            if(check(x,y)&&a[x][y]=='.'){
                p.push({x,y,t+2});
            }
        }
    }
    return -1;
}
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            cin>>a[i][j];
        }
    }
    int x,y;
    cin>>x>>y;
    cin>>ex>>ey;
    cout<<bfs(x,y);
}

郭晋龙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode走迷宫-leetcodeGo:leetcode刷题
07-06
走迷宫 leetcode 刷题记录 类型要点 链表 链表相关操作： 翻转 区间翻转 判断环 ---- 快慢指针 对称翻转 链表常用技巧 递归 定义双变量 let head = p = {}; p.next = l1 这类定义法则 广度遍历 要点： 需要一个队列 ...
牛牛走迷宫(BFS)
A1063348628的博客
07-17 64
有一个矩形迷宫(1 ≤ n,m ≤ 50)` #`表示墙 `.`表示空地起点(r1,c1)终点(r2,c2)每一步可以采取下面策略之一。接下来一行四个整数r1,c1,r2,c2分别表示起点与终点。第一行输入两个整数n,m (1 ≤ n,m ≤ 50)- 花费2秒的时间传送到四个基本方向最近的空地。最少需要几秒能从起点到达终点 如果不能输出-1。- 花费1秒的时间走向相邻的空地。另外30%的数据：n,m
牛牛走迷宫（bfs最短路）
chineseherofeng的博客
06-21 554
题目链接 思路：从题意走的步数最小可以知道这道题肯定是求最短路（一般我用bfs），但字典序最小卡住了我，其实要求字典序最小其实我们只需要把每步走的四个方向所代表的字符按字典序最小排列即可，即“DLRU”(先向下，再向左，再向右，最后向上)，那么bfs时字典序最小的路径总会在字典序的路径之前，这样所求的最短路便是符合要求的最短路。 ac代码： #include <iostream> #include <algorithm> #include <cstdio> #includ
牛牛的DRB迷宫I
维生素C吃多了会上火
02-10 684
题目描述 牛牛有一个n*m的迷宫，对于迷宫中的每个格子都为’R’,‘D’,'B’三种类型之一，'R’表示处于当前的格子时只能往右边走’D’表示处于当前的格子时只能往下边走，而’B’表示向右向下均可以走。 我们认为迷宫最左上角的坐标为(1,1)，迷宫右下角的坐标为(n,m)，除了每个格子有向右移动以及向下移动的限制之外，你也不能够走出迷宫的边界。 牛牛现在想要知道从左上角走到右下角不同种类的走法共有...
小白月赛26：E牛牛走迷宫（BFS）
mengxianQAQ的博客
06-18 352
题目链接小白月赛26 牛牛走迷宫 题目大意 一个n行，m列的只包含0和1矩阵，0表示可以走，1表示不能走。，从{1,1}开始移动，一次移动一格，可以向上下左右移动，条路径步数一样，他会选择走字典序最小的那条。。 输出要求：如果牛牛不能走到终点，请输出"-1",如果可以走到终点，第一行请输出牛牛的最小步数k。 接下来一行，输出一个长度为k的字符串(仅包含’D’、‘L’、‘R’、‘U’)表示牛牛的路径。(D表示向下，L表示向左，R表示向右，U表示向上) 分析： 要遍历所有的路径，可以用BFS来进行搜索，向四个方
微信小游戏~在线走迷宫-项目源码
最新发布
03-09
微信小游戏项目源码，是经典怀旧的走迷宫游戏。 探索迷宫寻宝，一种探索与冒险的游戏。 用微信开发者工具选小游戏导入即可，可正常编译运行，请放心下载。
open judge走迷宫-找所有路径
11-18
B01:走迷宫-找所有路径 View Submit Statistics Clarify 总Time Limit: 1000ms 单个测试点时间限制: 100ms Memory Limit: 64kB Description 有一个m*n格的迷宫(表示有m行、n列)，其中有可走的也有不可走的，如果...
迷宫-地下迷宫-uniapp-项目源码
06-06
这是一个uniapp H5源码【迷宫】项目完整例子，以下还有↓ ...类似走出迷宫游戏，探索与冒险玩法， 值得参考学习研究，请看相关配套的文章https://blog.csdn.net/zs1028/article/details/131035708
字符迷宫之最短路径走迷宫-易语言
06-12
字符迷宫之最短路径走迷宫
1254：走出迷宫
zqhf123的博客
02-14 470
1254：走出迷宫 时间限制: 1000 ms 内存限制: 65536 KB 提交数: 5034 通过数: 2298 【题目描述】 当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。 假设你已经得到了一个n*m的迷宫的图纸，请你找出从起点到出口的最短路。 【输入】 第一行是两个整数n和m(1≤n,m≤100)，表示迷...
01迷宫（输出路线）
qq_17405183的博客
04-16 777
链接：01迷宫 来源：牛客网 题目描述 给出一个01迷宫，'0’代表空地，'1’代表墙 。 输出起点到终点的最短路的长度及路径。 规定：为了保证答案唯一，总会按照下(D)，上(U)，左(L)，右®的优先级行走。 假设当前点为（x, y)，规定方向如下： D:(x, y) -> (x, y+1) U:(x, y) ->(x, y-1) L:(x, y) ->(x-1, y) R:(x, y) ->(x+1, y) 输入描述: 第一行两个整数n，m，代表迷宫的长和宽。 接下来n行，每行
有一个N*M的格子迷宫，1代表该格子为墙，不能通过，0代表可以通过，另外，在迷宫中 有一些传送门，走到传送门的入口即会自动被传送到传送门的出口（一次传送算1步）。人在迷宫中可以尝试 上下左右四个方向移
热门推荐
chenjiazhanxiao的博客
04-12 1万+
  #include &lt;iostream&gt; #include &lt;string&gt; #include &lt;vector&gt; #include &lt;queue&gt; #include &lt;utility&gt; #include &lt;cstdio&gt; using namespace std; const int MAX_N = 100; cons...
习题：走迷宫2 （java bfs）
pioneer的博客
02-25 1662
package lanqiaobei; import java.util.*; /* 习题：走迷宫2 给你一个n行m列的二维迷宫。'S'表示起点，'T' 表示终点，'#' 表示墙壁，'.' 表示平地。你需要从 'S' 出发走到 'T'，每次只能上下左右走动，并且不能走出地图的范围以及不能走到墙壁上。请你计算出走到终点需要走的最少步数。 输入格式 第一行输入n, m表示迷宫大小。(1≤n,m...
牛客寒假训练营3 A 牛牛的DRB迷宫I
atnanajiang的博客
02-09 143
题目要求 链接：https://ac.nowcoder.com/acm/contest/3004/A 来源：牛客网 题目描述 牛牛有一个n*m的迷宫，对于迷宫中的每个格子都为’R’,‘D’,'B’三种类型之一，'R’表示处于当前的格子时只能往右边走’D’表示处于当前的格子时只能往下边走，而’B’表示向右向下均可以走。 我们认为迷宫最左上角的坐标为(1,1)，迷宫右下角的坐标为(n,m)，除了每个格...
迷宫问题(回溯思想)
EmotionComputer
08-14 1459
题目链接：https://www.luogu.org/problem/P1605 题目背景: 给定一个N*M方格的迷宫，迷宫里有T处障碍，障碍处不可通过。给定起点坐标和终点坐标，问: 每个方格最多经过1次，有多少种从起点坐标到终点坐标的方案。在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。 输入格式： 第一行N、M和T，N为行，M为列，T为障碍总数。第二行起点坐标SX...
走迷宫（bfs）
zxker
03-04 2705
给你一个 n 行 m 列的二维迷宫。'S'表示起点，'T' 表示终点，'#' 表示墙壁，'.' 表示平地。你需要从 'S' 出发走到 'T'，每次只能上下左右走动，并且不能走出地图的范围以及不能走到墙壁上。请你计算出走到终点需要走的最少步数。输入格式第一行输入 nnn, mmm 表示迷宫大小。(1≤n,m≤100)(1 \leq n,m \leq 100)...
牛客--迷路的牛牛C++--为程序媛之崛起而CODE
weixin_39100602的博客
09-13 162
@Ada_Chow(网易–迷路的牛牛–程序媛的思路分享) 迷路的牛牛–C++ 牛牛去犇犇老师家补课，出门的时候面向北方，但是现在他迷路了。虽然他手里有一张地图，但是他需要知道自己面向哪个方向，请你帮帮他。 输入描述 每个输入包含一个测试用例。 每个测试用例的第一行包含一个正整数，表示转方向的次数N(N<=1000)。 接下来的一行包含一个长度为N的字符串，由L和R组成，L表示向左转，R表示...
关于构造和二进制，题目：牛牛的DRB迷宫Ⅱ（源自牛客竞赛2020年寒假集训）
qq_45007483的博客
02-11 421
关于构造和二进制，题目：牛牛的DRB迷宫Ⅱ（源自牛客竞赛2020年寒假集训） 题目： 链接：https://ac.nowcoder.com/acm/contest/3004/B 来源：牛客网 题目描述 牛牛有一个n*m的迷宫，对于迷宫中的每个格子都为’R’,‘D’,'B’三种类型之一，'R’表示处于当前的格子时只能往右边走’D’表示处于当前的格子时只能往下边走，而’B’表示向右向下均可以走。 ...
用q-learning走迷宫代码
06-09
下面是一个使用 Q-learning 算法解决迷宫问题的 Python 代码示例： ```python import numpy as np import random # 定义迷宫环境 maze = np.array([ [0, 0, 0, 0, 0, 0, 0, 1], [0, 1, 1, 0, 1, 1, 0, 1], [0, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

郭晋龙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值