精华内容
下载资源
问答
  • 解题思路 最短路问题,直接广搜。 代码 #include<iostream> #include<queue> #include<cstring> using namespace std; struct Node { int x; int y; int t; bool operator < (const No.....

    题目大意

    在这里插入图片描述
    在这里插入图片描述

    解题思路

    • 最短路问题,直接广搜。

    代码

    #include<iostream>
    #include<queue>
    #include<cstring>
    using namespace std;
    struct Node
    {
        int x;
        int y;
        int t;
        bool operator < (const Node&A)const
        {
            return t > A.t;
        }
    }tmp;
    priority_queue<Node, vector<Node> > Q;
    const int MAX = 105;
    char grad[MAX][MAX];
    bool visited[MAX][MAX];
    int dir[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
    int N, M;
    int sx, sy;
    int bfs()
    {
        tmp.x = sx;
        tmp.y = sy;
        tmp.t = 0;
        while(!Q.empty())
            Q.pop();
        visited[sx][sy] = 1;
        Q.push(tmp);
        while(!Q.empty())
        {
            Node top = Q.top();
            Q.pop();
            for(int i=0; i<4; i++)
            {
                int nx = top.x + dir[i][0];
                int ny = top.y + dir[i][1];
                if(nx < 0 || nx >= N || ny < 0 || ny >= M)
                    continue;
                if(grad[nx][ny] == '#')
                    continue;
                if(visited[nx][ny])
                    continue;
                if(grad[nx][ny] == 'G')
                    return top.t + 1;
                tmp.x = nx;
                tmp.y = ny;
                tmp.t = top.t + 1;
                visited[nx][ny] = 1;
                Q.push(tmp);
            }
        }
        return -1;
    }
    int main()
    {
        cin >> N >> M;
        memset(visited, 0, sizeof(visited));
        for(int i=0; i<N; i++)
        {
            for(int j=0; j<M; j++)
            {
                cin >> grad[i][j];
                if(grad[i][j] == 'S')
                {
                    sx = i;
                    sy = j;
                }
            }
        }
        int ans = bfs();
        cout << ans << endl;
    }
    
    
    展开全文
  • 设计思路程序首先要考虑迷宫的表示,这是一个二维关系图,所以可选择二维数组来存储。数组元素只有两种值0和1,分别代表通路和墙壁。图形的显示可以根据数组元素的值来确定。如果是人工探索,则依据按键来确定探索...
  • 这道题当时比赛的时候没有做起,应为要急着做毕业设计,也就没怎么认真思考。下来自己做的时候最开始的思路是深搜,后来发现深搜如果不剪枝的话肯定会超时的,于是乎就用了广搜 大体思路: 和普通的广搜一样一层一...

            这道题当时比赛的时候没有做起,应为要急着做毕业设计,也就没怎么认真思考。下来自己做的时候最开始的思路是深搜,后来发现深搜如果不剪枝的话肯定会超时的,于是乎就用了广搜

            大体思路:

                    和普通的广搜一样一层一层的遍历,不过这里要用vis数组记录图上某个点是否被访问,其中的访问分为两种,一种是带着钥匙访问,一种是不带着钥匙访问,所以vis 数组应该开成三维数组。


    #include <iostream>
    #include <algorithm>
    #include <string>
    #include <vector>
    #include <map>
    #include <cstdio>
    #include <queue>
    #include <cstring>
    #define INF 0x3f3f3f3f
    #define MAX_N 510
    using namespace std;
    struct node{
    	int x,y,step,k;
    };
    int dir[4][2] = {
    	{-1,0},
    	{1,0},
    	{0,1},
    	{0,-1}
    };
    int vis[MAX_N][MAX_N][2];
    int n,m;
    char g[MAX_N][MAX_N];
    
    int bfs(int x,int y){
    	memset(vis,0,sizeof(vis));
    	queue<node> que;
    	node p;
    	p.x = x,p.y = y,p.k = 0,p.step = 0;
    	vis[x][y][0] = 1;
    	que.push(p);
    	while(!que.empty()){
    		node p = que.front();que.pop();
    	//	printf("%d  .. %d \n",p.x,p.y );
    		if (g[p.x][p.y] == 'E') return p.step;
    		for(int i = 0;i < 4;++i){
    			node q;
    			q.x = p.x + dir[i][0],q.y = p.y + dir[i][1];
    			if(0 <= q.x && q.x < n && 0 <= q.y && q.y < m && g[q.x][q.y] != '#'){
    				if(g[q.x][q.y] == 'K') q.k = 1;
    				else q.k = p.k;
    				// 如果已经访问了,就不必访问了
    				if(vis[q.x][q.y][q.k]) continue;
    				vis[q.x][q.y][q.k] = 1;
    				// 如果遇到E 但是没有钥匙,不能经过E这个点
    				if(g[q.x][q.y] == 'E' && !q.k) continue;
    
    				q.step = p.step + 1;
    				que.push(q);
    			}
    		}
    	}
    
    return -1;
    
    }
    
    int main(){
    	// freopen("test.txt","r",stdin);
    	int T;
    	cin >> T;
    	while(T--){
    		int sx,sy;
    		cin >> n >> m;
    		for (int i = 0;i < n;++i){
    			scanf("%s",g[i]);
    		}
    		for (int i = 0;i < n;++i){
    			for (int j = 0;j < m;++j){
    				if(g[i][j] == 'P'){
    					sx = i,sy = j;
    					break;
    				}
    			}
    		}
    		int ans = -1;
    		ans = bfs(sx,sy);
    		if (ans != -1){
    			cout << ans << endl;	
    		}
    		else{
    			cout << "No solution" << endl;
    		}
    	}
    
    
    
    	return 0;
    }
    

    展开全文
  • 思路:两遍bfs,找到p到k的情况,记录时间;找到E到k的情况,记录时间。题目超时点在于输入需要用scanf。如果不用scanf可以用cin加速挂。 AC代码: 1 #include<iostream> 2 #include<bits/stdc++.h&...

    题目链接:https://www.nowcoder.com/acm/contest/96/G

    思路:两遍bfs,找到p到k的情况,记录时间;找到E到k的情况,记录时间。题目超时点在于输入需要用scanf。如果不用scanf可以用cin加速挂。

    AC代码:

      1 #include<iostream>
      2 #include<bits/stdc++.h>
      3 #include<queue>
      4 #define INF 10000000
      5 using namespace std;
      6 int vis[505][505];
      7 int ans[505][505];
      8 char a[505][505];
      9 int fx[4][2]={{-1,0},{0,-1},{1,0},{0,1}};
     10 struct Node{
     11     int x,y,step;
     12 };
     13 void bfs(int x,int y){
     14     queue < Node > q;
     15     Node now,nxt;
     16     now.x=x;
     17     now.y=y;
     18     now.step=0;
     19     q.push(now);
     20     vis[x][y]=1;
     21     while(!q.empty()){
     22         now=q.front();
     23         q.pop();
     24         if(a[now.x][now.y]=='K'){
     25             ans[now.x][now.y]=now.step;
     26         }
     27         for(int i=0;i<4;i++){
     28             int tmpx=now.x+fx[i][0];
     29             int tmpy=now.y+fx[i][1];
     30             if(!vis[tmpx][tmpy]&&a[tmpx][tmpy]!='#'){
     31                 nxt.x=tmpx;
     32                 nxt.y=tmpy;
     33                 vis[nxt.x][nxt.y]=1;
     34                 nxt.step=now.step+1;
     35                 q.push(nxt);
     36             }
     37         }
     38     }
     39     return ;
     40 }
     41 int BFS(int x,int y){
     42     queue < Node > q;
     43     int mini=INF;
     44     Node now,nxt;
     45     now.x=x;
     46     now.y=y;
     47     now.step=0;
     48     q.push(now);
     49     vis[x][y]=1;
     50     while(!q.empty()){
     51         now=q.front();
     52         q.pop();
     53         if(a[now.x][now.y]=='K'&&ans[now.x][now.y]){
     54             mini=min(mini,ans[now.x][now.y]+now.step);
     55         }
     56         for(int i=0;i<4;i++){
     57             int tmpx=now.x+fx[i][0];
     58             int tmpy=now.y+fx[i][1];
     59             if(!vis[tmpx][tmpy]&&a[tmpx][tmpy]!='E'&&a[tmpx][tmpy]!='#'){
     60                 nxt.x=tmpx;
     61                 nxt.y=tmpy;
     62                 nxt.step=now.step+1;
     63                 q.push(nxt);
     64                 vis[nxt.x][nxt.y]=1;
     65             }
     66         }
     67     }
     68     return mini;
     69 }
     70 int main(){
     71     // ios::sync_with_stdio(false);  加速挂
     72     int T;
     73     cin>>T;
     74     while(T--){
     75         int n,m;
     76         cin>>n>>m;
     77         memset(ans,0,sizeof(ans));
     78         for(int i=0;i<504;i++)
     79             for(int j=0;j<504;j++)
     80                 a[i][j]='#';
     81         for(int i=1;i<=n;i++){
     82             char c=getchar();
     83             for(int j=1;j<=m;j++){
     84                 scanf("%c",&a[i][j]);
     85             }
     86         }
     87         for(int i=1;i<=n;i++){
     88             for(int j=1;j<=m;j++){
     89                 if(a[i][j]=='E'){
     90                     memset(vis,0,sizeof(vis));
     91                     bfs(i,j);
     92                     break;
     93                 }
     94             }
     95         }
     96         int mini;
     97         for(int i=1;i<=n;i++){
     98             for(int j=1;j<=m;j++){
     99                 if(a[i][j]=='P'){
    100                     memset(vis,0,sizeof(vis));
    101                     mini=BFS(i,j);
    102                     break;
    103                 }
    104             }
    105         }
    106         if(mini==INF){
    107             cout<<"No solution"<<endl;
    108         }else{
    109             cout<<mini<<endl;
    110         }
    111     }
    112     return 0;
    113 }        

     

    转载于:https://www.cnblogs.com/ISGuXing/p/8888720.html

    展开全文
  • 解题思路:bfs走两遍,第一次从起点到各个钥匙,第二次从终点到各个钥匙,最后更新最小路径和。 #include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;queue&gt; using ...

    https://www.nowcoder.com/acm/contest/96/G

    解题思路:bfs走两遍,第一次从起点到各个钥匙,第二次从终点到各个钥匙,最后更新最小路径和。

    #include<iostream>
    #include<cstring>
    #include<queue>
    using namespace std;
    #define INF 0x3f3f3f3f
    const int N=505;
    struct node{
        int x,y,step;
    };
    int px[]={0,0,1,-1},py[]={1,-1,0,0};
    int ans,n,m;
    int vis[N][N],sum[N][N],k[N][N];
    char g[N][N];
    
    void bfs(int x,int y)
    {
        memset(vis,0,sizeof(vis));
        queue<node> q;
        q.push({x,y,0});
        vis[x][y]=1;
        while(!q.empty())
        {
            node t=q.front();
            q.pop();
            for(int i=0;i<4;i++)
            {
                int dx=t.x+px[i];
                int dy=t.y+py[i];
                if(!vis[dx][dy]&&dx>=0&&dx<n&&dy>=0&&dy<m&&g[dx][dy]!='#'&&g[dx][dy]!='E')
                {
                    vis[dx][dy]=1;
                    if(g[dx][dy]=='K')
                    {
                        k[dx][dy]+=t.step+1;
                        sum[dx][dy]++;
                    }               
                    if(sum[dx][dy]==2)
                      ans=min(ans,k[dx][dy]);
                    q.push({dx,dy,t.step+1});
                }
            }
        }
    }
    
    int main()
    {
        int t;
        cin>>t;
        while(t--)
        {
            cin>>n>>m;
            memset(sum,0,sizeof(sum));
            memset(k,0,sizeof(k));
            int sx,sy,ex,ey;
            for(int i=0;i<n;i++)
              for(int j=0;j<m;j++)
              {
                  cin>>g[i][j];
                  if(g[i][j]=='P')
                    sx=i,sy=j;
                  if(g[i][j]=='E')
                    ex=i,ey=j;
              }
            ans=INF;
            bfs(sx,sy);
            bfs(ex,ey);
            if(ans==INF)
              cout<<"No solution"<<endl;
            else
              cout<<ans<<endl;
        }
        return 0;
    } 
    展开全文
  • 迷宫小车】基于51单片机的迷宫电脑鼠的设计

    千次阅读 多人点赞 2020-11-21 03:41:27
    基于51单片机的迷宫电脑鼠的设计简介功能分析硬件驱动程序一、数码管驱动二、红外传感器组驱动三、步进电机驱动算法分析一、遍历迷宫1、定义绝对方向和相对方向2、记录当前坐标的迷宫信息3、选择一个方向4、向这个...
  • 迷宫问题的求解过程实际就是从入口开始一步一步地走到出口的过程 基本要求 输入一个任意大小的迷宫数据用递归和非递归两种方法求出一条走出迷宫的路径并将路径输出 二设计思路 在本程序中用两种方法求解迷宫问题-...
  • 一种走迷宫电脑鼠的设计与实现,包括設計思路程序設計,對迷宮鼠授索算法的改進。
  • 迷宫

    千次阅读 2016-09-03 20:23:05
    题目来自《挑战程序设计竞赛》2.1最基础的穷竭搜索 1.题目描述 给定一个大小为N*M的迷宫迷宫由通道和墙壁组成,每一步都可以向邻接的上下左右四个的通道移动。求从起点到终点所需要的最小步数。假定本题从起点一定...
  • 昨天比赛刚结束 题目还没找着 ...解题思路: BFS遍历过程中记录路径,既然题目中要求了遍历的顺序就按题目中的来遍历。 记录路径不要忘记在扩展每一个点的时候把上一个点的信息先继承下来,因为这里使用的是数组...
  • 已知情报藏在一个地下迷宫里,迷宫只有一个入口,里面有很多条通路,每条路通向一扇门。每一扇门背后或者是一个房间,或者又有很多条路,同样是每条路通向一扇门…… 他的手里有一张表格,是其他间谍帮他收集到的...
  • 本资源是完整的课程设计,不仅有源码,还有问题描述 设计思路 数据结构设计 功能函数设计 程序代码
  • 代码及设计思路如下图: #include<stdio.h> # define M 5 //定义行数 # define N 5 //定义列数 # define MaxSize 100 //栈最多元素个数 int mg[M+2][N+2]=//一个迷宫数组(M+2行,N+2列),四周加上均为1的外...
  • 文章目录A题——迷宫路径问题问题描述思路总结代码B题——倒水问题问题描述思路总结代码 A题——迷宫路径问题 问题描述 东东有一张地图,想通过地图找到妹纸。地图显示,0表示可以走,1表示不可以走,左上角是入口,...
  • C语言 栈 数据结构 迷宫求解(附完整代码)

    千次阅读 多人点赞 2018-11-15 20:20:49
    一、程序设计思路 1、题目:应用栈实现迷宫游戏 要求:以书中3.2.4节迷宫求解为基础实现迷宫游戏,游戏运行时显示...其中,程序设计思路部分以文字叙述为主,详细阐述迷宫和玩家在迷宫中移动的基本操作;程序源代...
  • 迷宫的状态会改变,最开始没想明白怎么用bfs去做,不过提供翻译的那个博主给了思路,把问题分解成多次简单的bfs。 #include <iostream> #include <cstring> #include <queue> #include <...
  • 经典迷宫问题,输入5×5的二维数组表示迷宫,0表示可以走,1表示不可以走,要求输出从入口 (0,0)到出口(4,4)的最短路径。 思路: BFS板子题,为了记录路径,在结构体中添加记录父节点的变量,使用以head、tail...
  • 目录A - Maze题意思路:总结:代码:B - Pour Water题意思路:总结&疑问:代码: A - Maze 题意 东东有一张地图,想通过地图找到妹纸。地图显示,0表示可以走,1表示不可以走,左上角是...设计迷宫单元结构...
  • 2020安徽省大学生程序设计大赛题解E E 收集圣物 题目 标签 队列,图的BFS,状态压缩,状态转移 分析 类似于迷宫求最短路径问题,与传统问题不同的是,本题含有多个终点,并且前往终点的路上增加了门钥匙这一条件。...
  • 题目思路: 在认真阅读题目之后,这个题目与我们之前练习过得搜索(DFS,BFS)时的迷宫问题很相似,迷宫问题是,在一个二维数组中,界定好了迷宫,让我们在迷宫内部中通过DFS,BFS的搜索来进行行走,获取一些相关的...
  • 数据结构实践——迷宫问题之图深度优先遍历解法

    万次阅读 多人点赞 2015-11-08 15:36:59
     设计一个程序,采用深度优先遍历算法的思路,解决迷宫问题。  (1)建立迷宫对应的图数据结构,并建立其邻接表表示。  (2)采用深度优先遍历的思路设计算法,输出从入口(1,1)点到出口(M,N)的所有迷宫路径。 ...
  • 题后总结思路迷宫无权重问题,要求求最短路径,实际上就是考差宽搜; 数列掌握STL容器的使用很重要,例如Queue,Abstract.SimpleEntry; 题目描述 众所周知,Teutonic Knight是某RTS游戏中,移动速度最快的角色...
  • 数据结构——迷宫问题

    千次阅读 2019-01-23 11:09:37
    数据结构课程设计 迷宫问题求解(栈和队列) 任务:可以输入一个任意大小的迷宫数据,用非递归的方法求...该课设意在考察栈和队列的数据结构,我主要说一下代码的设计思路,供诸君参考,也方便以后自己复习。 ...
  • 【原创】转载请注明出处 【浙江大学 程序设计专题】 【地图求解器】 本题目要求输入一个迷宫地图,输出从起点到终点的路线。 基本思路是从起点(Sx,Sy)每次枚举该格子上下左右四个方向,直到走到终点(Tx,Ty)。方法...
  • 逃离ACM迷宫(BFS)

    2017-07-27 16:18:02
    题目描述如下图所示的是一个由程序设计题目组成的ACM迷宫迷宫的左上角是入口,右下角是出口。迷宫中每一个格子都有一个程序设计题目,挑战者要AC该题目后才能通过,大于0的数字表示AC该题目所需的最短时间。数字...
  • 设计一个程序,采用深度优先遍历算法的思路,解决迷宫问题。  (1)建立迷宫对应的图数据结构,并建立其邻接表表示。  (2)采用深度优先遍历的思路设计算法,输出从入口(1,1)点到出口(M,N)的所有迷宫路径。 ...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 156
精华内容 62
关键字:

迷宫程序设计思路