广搜+深搜(搜索最短路径+最短步数)

#include <iostream>
#include <string.h>
#include <stack>
#include <queue>
#include <algorithm>
using namespace std;
const int maxn=10;

struct P
{
	int x,y;
}point[maxn];

struct PP
{
	int fx,fy;
}path[maxn][maxn];

int num[maxn][maxn];
int vis[maxn][maxn];
int dx[4]={0,-1,1,0};
int dy[4]={-1,0,0,1};
int total=0;

int sx=1,sy=1;
int ex=4,ey=4;

char map[6][6]=
{
    {‘#‘,‘#‘,‘#‘,‘#‘,‘#‘,‘#‘},
    {‘#‘,‘.‘,‘.‘,‘.‘,‘#‘,‘#‘},
    {‘#‘,‘.‘,‘#‘,‘.‘,‘.‘,‘#‘},
    {‘#‘,‘.‘,‘.‘,‘.‘,‘#‘,‘#‘},
    {‘#‘,‘#‘,‘.‘,‘.‘,‘.‘,‘#‘},
    {‘#‘,‘#‘,‘#‘,‘#‘,‘#‘,‘#‘}
};   

int ok(int x,int y)
{
	 if(x<0||x>5||y<0||y>5)
        return 0;
    if(map[x][y]==‘#‘)
        return 0;
    if(vis[x][y]==1)
        return 0;
    return 1;
}

void dfs(int x,int y,int step)
{
	if(x==ex&&y==ey)
	{
		total++;
		for(int i=0;i<step;i++)
		{
			cout<<"("<<point[i].x<<","<<point[i].y<<")";
		}
		cout<<endl;
		return;
	}

	for(int i=0;i<4;i++)
	{
		int curx=x+dx[i];
		int cury=y+dy[i];
		if(ok(curx,cury))
		{
			vis[curx][cury]=1;
			point[step].x=curx;
			point[step].y=cury;
			dfs(curx,cury,step+1);
			vis[curx][cury]=0;
		}
	}
}

void bfs(int x,int y)
{
	num[x][y]=0;
	queue<P>q;
	P a,b;
	a.x=x;
	a.y=y;
	path[a.x][a.y].fx=0;
	path[a.x][a.y].fy=0;
	q.push(a);
	while(!q.empty())
	{
		b=q.front();
		q.pop();
		for(int i=0;i<4;i++)
		{
			a.x=b.x+dx[i];
			a.y=b.y+dy[i];
			while(ok(a.x,a.y))
			{
				vis[a.x][a.y]=1;
				q.push(a);
				path[a.x][a.y].fx=dx[i];
				path[a.x][a.y].fy=dy[i];
				num[a.x][a.y]=num[b.x][b.y]+1;
			}
		}
	}
}

void print(int x,int y)
{
	if(x==sx&&y==sy)
	{
		cout<<"("<<x<<","<<y<<")";
		return;
	}
	print(x-path[x][y].fx,y-path[x][y].fy);
	cout<<"("<<x<<","<<y<<")";
} 

int main()
{
	memset(vis,0,sizeof(vis));
    memset(num,0,sizeof(num)); 

	point[0].x=sx;
	point[0].y=sy;
	vis[sx][sy]=1;
	dfs(sx,sy,1);
	cout<<"There are "<<total<<" paths to arrive."<<endl;

	memset(vis,0,sizeof(vis));
	vis[sx][sy]=1;
	bfs(sx,sy);

    for(int i=0;i<6;i++)
    {
        for(int j=0;j<6;j++)
            cout<<num[i][j]<<" ";
        cout<<endl;
    }  

    cout<<endl;
    cout<<num[ex][ey]<<endl<<endl;;
    print(ex,ey);
	cout<<endl;
    return 0;
}

  

原文地址:https://www.cnblogs.com/KasenBob/p/10624186.html

时间: 2024-08-01 00:16:58

广搜+深搜(搜索最短路径+最短步数)的相关文章

广搜深搜二

<span style="color:#330099;">/* C - 广搜 基础 Time Limit:1000MS Memory Limit:65536KB 64bit IO Format:%I64d & %I64u Submit Status Description A friend of you is doing research on the Traveling Knight Problem (TKP) where you are to find the

B广搜深搜

<span style="color:#330099;">/* B - 广搜/深搜 基础 Time Limit:1000MS Memory Limit:30000KB 64bit IO Format:%I64d & %I64u Submit Status Description There is a rectangular room, covered with square tiles. Each tile is colored either red or blac

BZOJ_1615_[Usaco2008_Mar]_The Loathesome_Hay Baler_麻烦的干草打包机_(模拟+宽搜/深搜)

描述 http://www.lydsy.com/JudgeOnline/problem.php?id=1615 一个主动轮带着一些轮子转,轮子带着轮子转,轮子带着轮子转...一个非主动轮只会被一个轮子带着转.求从主动轮到某一个轮子的路上所有轮子的转速的绝对值之和. 分析 从起点开始,枚举相接触的轮子,只要不是之前路上的(带着当前轮子转的)轮子,就继续往下走.宽搜深搜都可以. 注意: 1.%.0lf是会四舍五入的!所以要强制转化成int. 宽搜: 1 #include <bits/stdc++.h

深搜 ,广搜,队列 nyoj 27 水池数目

水池数目 时间限制:3000 ms  |  内存限制:65535 KB 难度:4 描述 南阳理工学院校园里有一些小河和一些湖泊,现在,我们把它们通一看成水池,假设有一张我们学校的某处的地图,这个地图上仅标识了此处是否是水池,现在,你的任务来了,请用计算机算出该地图中共有几个水池. 输入 第一行输入一个整数N,表示共有N组测试数据 每一组数据都是先输入该地图的行数m(0<m<100)与列数n(0<n<100),然后,输入接下来的m行每行输入n个数,表示此处有水还是没水(1表示此处是水

深搜和广搜

先说说这个神秘的深搜: 前几天我心中的大牛给我讲了深搜感觉还是挺简单的,可大牛告诉我深搜深搜深的让你不知道怎么搜 我们也是从一道题来看:n的全排列 比如说3的全排列 123 213 321 这就是全排列   在没学过深搜的时候我们会用for循环来做这道题 但是如果n很大的时候就不行了 所以我们就一定要深搜了 其实在我看来深搜和递归是亲兄弟 深搜就是递归的加强版 我先写一个简单的dfs(深搜)函数的代码 #include<stdio.h> int dfs(int x) { if(x > n

图的广搜与深搜模板

题目传送门 深搜 深搜,顾名思义就是往深了搜.每次,只要你发现下一个点可以走,你马上走上去 就行啦!!就这样不断递归,直到遇到你的边界条件,撞到了南墙,你再也走不下去了,哼哼,我回头退回去!! 可以跟大家看下样例::(自己去题面看图) 样例是从1出发,先走2,然后走5,发现走不下去,退回来. 站在2这里,我们又往6走,发现又走不下去了,退回2.此时2没有点可走,退回1,去往3. 在3点,我们前往7,然后再往8,无路可走,退回7->3——>1.最后走4. 广搜和深搜略有不同. 广搜就是先站在目前

最短路问题------分别用深搜和广搜去解题

最少步数 时间限制:3000 ms | 内存限制:65535 KB 难度:4 描述 这有一个迷宫,有0~8行和0~8列: 1,1,1,1,1,1,1,1,1 1,0,0,1,0,0,1,0,1 1,0,0,1,1,0,0,0,1 1,0,1,0,1,1,0,1,1 1,0,0,0,0,1,0,0,1 1,1,0,1,0,1,0,0,1 1,1,0,1,0,1,0,0,1 1,1,0,1,0,0,0,0,1 1,1,1,1,1,1,1,1,1 0表示道路,1表示墙. 现在输入一个道路的坐标作为起点

7.23 深搜广搜

深搜(DFS)  关键词:回溯 栈实现,(递归本质和栈一样)一直走到底再回溯,时间复杂度高,空间低 #include<iostream> #include<cstring> using namespace std; int R,C; char maps[40][40]; int dp[40][40]; int dir[2][4]={{1,0,0,-1},{0,1,-1,0}}; int ans=1<<30; void DFS(int x,int y,int step){

深搜和广搜的原理及优缺点

原文来源:https://blog.csdn.net/dark_cy/article/details/88926435 深搜原理深搜,顾名思义,是深入其中.直取结果的一种搜索方法. 如果深搜是一个人,那么他的性格一定倔得像头牛!他从一点出发去旅游,只朝着一个方向走,除非路断了,他绝不改变方向!除非四个方向全都不通或遇到终点,他绝不后退一步!因此,他的姐姐广搜总是嘲笑他,说他是个一根筋.不撞南墙不回头的家伙. 深搜很讨厌他姐姐的嘲笑,但又不想跟自己的亲姐姐闹矛盾,于是他决定给姐姐讲述自己旅途中的经