SDUT--找朋友--BFS&&DFS

找朋友

Time Limit: 1000ms   Memory limit: 65536K  有疑问?点这里^_^

题目描述

X,作为户外运动的忠实爱好者,总是不想呆在家里。现在,他想把死宅Y从家里拉出来。问从X的家到Y的家的最短时间是多少。

为了简化问题,我们把地图抽象为n*n的矩阵,行编号从上到下为1 到 n,列编号从左到右为1 到 n。矩阵中’X’表示X所在的初始坐标,’Y’表示Y的位置 , ’#’表示当前位置不能走,’ * ’表示当前位置可以通行。X每次只能向上下左右的相邻的 ’*’ 移动,每移动一次耗时1秒。

输入

多组输入。每组测试数据首先输入两个整数n,m(1<= n ,m<=15 )表示地图大小。接下来的n 行,每行n个字符。保证输入数据合法。

输出

若X可以到达Y的家,输出最少时间,否则输出 -1。

示例输入

3 3
X#Y
***
#*#
3 3
X#Y
*#*
#*#

示例输出

4
-1

提示

4个搜索方向,上下左右,感觉dfs不太适合这类题,太慢,尤其是按不同的搜索顺序,比如按上下右左搜,竟然TLE。。稍微调了一下方向 70ms过

bfs就好多了,搜到了直接退出。

#include <cstdio>//BFS
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
char ma[20][20];
bool vis[20][20];
typedef struct node
{
	int x;
	int y;
	int time;
};
int n,m;
int mov[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
void bfs(int x,int y)
{
  queue <node> Q;
  node t;
  t.x=x;t.y=y;t.time=0;
  Q.push(t);
  vis[x][y]=1;
  while(!Q.empty())
  {
  	node v=Q.front();Q.pop();
  	if(ma[v.x][v.y]=='Y')
	{
		cout<<v.time<<endl;
		return ;
	}
  	for(int i=0;i<4;i++)
	{
		t.x=v.x+mov[i][0];
		t.y=v.y+mov[i][1];
		if(0<=t.x&&t.x<n&&0<=t.y&&t.y<m&&!vis[t.x][t.y]&&ma[t.x][t.y]!='#')
		{
			t.time=v.time+1;
			vis[t.x][t.y]=1;
		    Q.push(t);
		}
	}
  }
  puts("-1");
}

int main()
{
	int i,j;
	while(cin>>n>>m)
	{
		memset(vis,0,sizeof(vis));
		for(i=0;i<n;i++)
			cin>>ma[i];
		for(i=0;i<n;i++)
		{
			for(j=0;j<m;j++)
            {
			   if(ma[i][j]=='X')
				break;
		    }
		    if(j<m)
				break;
		}
		bfs(i,j);
	}
    return 0;
}
#include <cstdio>//DFS
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
const int INF=1<<20;

struct node
{
	int x,y,ans;
};
char ma[16][16];
int vis[16][16];
int n,m,mi;
int mv[4][2]={{0,1},{1,0},{-1,0},{0,-1}};
void DFS(int x,int y,int ans)
{
    if(ans>=mi)
	{
		return ;
	}
	if(ma[x][y]=='Y')
	{
		if(ans<mi)
		{
			mi=ans;
		}
		return ;
	}
    node f;
  	for(int i=0;i<4;i++)
	{
		f.x=x+mv[i][0];
		f.y=y+mv[i][1];
		if(0<=f.x&&f.x<n&&0<=f.y&&f.y<m&&!vis[f.x][f.y]&&ma[f.x][f.y]!='#')
		{
			vis[f.x][f.y]=1;
			DFS(f.x,f.y,ans+1);
			vis[f.x][f.y]=0;
		}
	}
}
int main()
{

	while(~scanf("%d%d",&n,&m))
	{
		memset(vis,0,sizeof(vis));
		for(int i=0;i<n;i++)
			scanf("%*c%s",ma[i]);
		int i,j;
		for(i=0;i<n;i++)
		{
			for(j=0;j<m;j++)
            {
			   if(ma[i][j]=='X')
				{
					break;
				}
		    }
		    if(j<m)
				break;
		}
		mi=INF;
		vis[i][j]=1;
		DFS(i,j,0);
		if(mi<INF)
		   printf("%d\n",mi);
		else
		   puts("-1");
	}
    return 0;
}

SDUT--找朋友--BFS&&DFS

时间: 2024-11-08 19:17:09

SDUT--找朋友--BFS&&DFS的相关文章

HDU ACM 1044 Collect More Jewels BFS+DFS

题意:在一个迷宫中,有一些宝物,从起点走到终点,问在给定的时间内,到达终点后所能拾取珠宝的最大价值. 分析(BFS+DFS): 1.求入口到第一个取宝物的地方的最短距离 2.求第i个取宝物的地方到第i+1个取宝物的地方的最短距离 3.求第n个取宝物的地方到出口的最短距离 4.保证以上3点能在时间L内实现的情况下,取得的宝石价值最大. BFS特点:对于解决最短或最少问题特别有效,而且寻找深度小,但缺点是内存耗费量大(需要开大量的数组单元来存储状态) DFS特点:对于解决遍历和求所有问题有效,对于问

建图方式一 之 ”前向星“ BFS&amp;&amp;DFS 简单应用

三种建图方式,邻接矩阵.前向星(边表集).邻接链表! 耗时一晚上 ,好好研究了一下 前向星,因为我的指针用的实在是很烂,所以还是 入赘 前向星吧. 问了学长,看了大牛们的博客,终于有点收获了,个人认为 前向星Very Well. 前向星 建图方法: 以储存边的方式来储存图.在构造图时,把边存放在数组里,不需使用指针,只需一个 next  即可是整个图构建完成 . 适用条件: 点集特别多的稀疏图,边数多且繁杂,开邻接矩阵会浪费大量内存. 时间复杂度: O(m),并不比邻接链表差. #include

UVALive - 6455 Stealing Harry Potter&#39;s Precious (bfs+dfs)

https://cn.vjudge.net/problem/UVALive-6455 题目大意:题目上给出一个地图,其中@是人在地图上的出发点,#是墙,' . '是路.然后给出几个点,这些点表示财宝的所在地.问人是否能够得到所有的宝藏,如果能够的话给出所有的宝藏的最短的路径. 解题思路:由于只有最多4个宝藏所在地,所以只要用bfs找出出发点和财宝所在地距离到达其他点的步数.因为最多只有4个宝藏,所以可以暴力找出出发点到所有宝藏的最短距离. 暴力代码: 1 #include<stdio.h> 2

POJ 1130(一道纯水,bfs+dfs)

POJ 1130 大概题意:给出一副图,求从起点到终点 (0->ET) 必须经过的一点. 我的思路:首先DFS求出经过每点的次数,必过的一点的次数一定最高,但是就这样吗?有可能有多个必过的点,所以还要找出离ET最近的点,这里就利用BFS逐层搜索的性质求每点到ET的距离. #include<iostream> #include<cstdio> #include<string.h> #include<iomanip> #include<queue&g

BFS/DFS算法介绍与实现(转)

广度优先搜索(Breadth-First-Search)和深度优先搜索(Deep-First-Search)是搜索策略中最经常用到的两种方法,特别常用于图的搜索.其中有很多的算法都用到了这两种思想,比如:Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想.BFS的思想:从一个图的某一个顶点V0出发,首先访问和V0相邻的且未被访问过的顶点V1.V2.--Vn,然后依次访问与V1.V2--Vn相邻且未被访问的顶点.如此继续,找到所要找的顶点或者遍历完整个图.由此

邻结矩阵的建立和 BFS,DFS;;

邻结矩阵比较简单,, 它的BFS,DFS, 两种遍历也比较简单,一个用队列, 一个用数组即可!!!但是邻接矩阵极其浪费空间,尤其是当它是一个稀疏矩阵的时候!!!---------------------------------------------------------------------------------------------------------------------------------------//邻接矩阵的建立和 其BFS, DFS, 遍历 #include <

hunnu--11548--找啊找啊找朋友

找啊找啊找朋友 Time Limit: 1000ms, Special Time Limit:2500ms, Memory Limit:65536KB Total submit users: 14, Accepted users: 11 Problem 11548 : No special judgement Problem description   小明和小红是一对好朋友,小明一有空就去找小红玩.但是小红飘忽的行踪让小明很是伤脑筋. 小红居住的小区的地下有当年抗战时期留下的地道,小红平时总是

Collect More Jewels(hdu1044)(BFS+DFS)

Collect More Jewels Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 6857    Accepted Submission(s): 1592 Problem Description It is written in the Book of The Lady: After the Creation, the cruel

SDUT 走迷宫(DFS)

走迷宫 Time Limit: 1000ms   Memory limit: 65536K  有疑问?点这里^_^ 题目描述 一个由n * m 个格子组成的迷宫,起点是(1, 1), 终点是(n, m),每次可以向上下左右四个方向任意走一步,并且有些格子是不能走动,求从起点到终点经过每个格子至多一次的走法数. 输入 第一行一个整数T 表示有T 组测试数据.(T <= 110) 对于每组测试数据: 第一行两个整数n, m,表示迷宫有n * m 个格子.(1 <= n, m <= 6, (n