1. 程式人生 > >迷宮最短路徑dfs和bfs程式碼分析

迷宮最短路徑dfs和bfs程式碼分析

dfs用遞迴一步步試探,在所有路徑中選出最短的一條路徑

程式碼:

//0是路,1是牆 
#include<iostream>
#include<algorithm>
using namespace std;
int x1,y1,x2,y2;//起點座標終點座標
int c=999999; //步數 
int dir[4][2]={-1,0,1,0,0,-1,0,1};
int mg[5][5]={0,0,1,1,1,
              0,0,1,1,1,
              0,1,0,1,1,
              1,0,1,1,1,
              0,0,0,0,0
			 };
void dfs(int x,int y,int t)
{
	int i,xx,yy;
	if (x==x2&&y==y2)//到達終點 
	{
		c=min(c,t);//取最小值 
		return ;
	}
	mg[x][y]=1;//將走過的路設1,以免下次又以為這是一條路,又走回來 
	for (i=0;i<4;i++)
	{
		xx=x+dir[i][0];
		yy=y+dir[i][1];//生成新的方向座標 
		if (xx<0||xx>=5||yy<0||yy>=5||mg[xx][yy]==1)//超出地圖,或者為牆,則要重新換個方向走 
		 continue;
		dfs(xx,yy,t+1);//步數+1,以xx,yy為新的座標,來進行對下次的方向進行選擇又生成新的xxyy 
		mg[xx][yy]=0;//這一步是當走到終點了,或者是有一個xxyy座標上下左右都不能走,則要將剛走過的路(之前設為牆了)恢復成路 
	}
}
int main()
{
	cin>>x1>>y1>>x2>>y2;
	dfs(x1,y1,0);
	cout<<c;
	return 0;
}

bfs用佇列一層一層的走,每次只取最短的

程式碼:

#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
struct st
{
   int x,y,c=0;//行列座標xy,c為步數	
};
queue<struct st> xz;//建立一個佇列xy 
int dir[4][2]={-1,0,1,0,0,-1,0,1};
int mg[5][5]={0,0,1,1,1,
              0,0,0,1,1,
              0,1,0,1,1,
              0,0,0,1,1,
              0,0,0,0,0
			 };
int bfs(struct st s,struct st e)
{
	struct st t;
	int i;
	xz.push(s);//先將起點座標的資訊入隊 
	mg[s.x][s.y]=1;
	while (!xz.empty())//佇列為空,說明到達終點,完畢 
	{
		s=xz.front(); //獲取隊頭元素 
		xz.pop();//刪除後佇列為空 
		if (s.x==e.x&&s.y==e.y)//到達終點,返回步數c 
		  return s.c;
		for (i=0;i<4;i++)
		{
			t.x=s.x+dir[i][0];
			t.y=s.y+dir[i][1];
			if (t.x<0||t.x>=5||t.y<0||t.y>=5||mg[t.x][t.y])//不能走 
			 continue;
			 t.c=s.c+1;  //步數加1 
			 mg[t.x][t.y]=1;//走過的路賦1 
			 xz.push(t);// 將新的座標和步數資訊t入隊 
		}
	}
}
int main()
{
	struct st s,e;
	cin>>s.x>>s.y>>e.x>>e.y;
	cout<<bfs(s,e)<<endl;
	return 0;
}


打印出路徑

//輸入0為路,1為牆,5*5地圖 
//從左上角 走到 右下角 
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
int mg[5][5];
int dir[4][2]={-1,0,1,0,0,-1,0,1};
struct node
{
	int x,y,c;
}jl[5][5];//記錄路徑 
int bfs()
{
	int i;
	queue<struct node> Q;
	struct node s;
	struct node t;
	s.x=s.y=s.c=0;
	mg[s.x][s.y]=1;
	Q.push(s);
	while (!Q.empty())
	{
		s=Q.front();
		Q.pop();
		if(s.x==4&&s.y==4)//達到終點 
		{
			return s.c;
		}
		for (i=0;i<4;i++)
		{
			t.x=s.x+dir[i][0];
			t.y=s.y+dir[i][1];
			if (t.x>=0&&t.x<5&&t.y>=0&&t.y<5&&mg[t.x][t.y]==0)
			{
				t.c=s.c+1;
				jl[t.x][t.y].x=s.x;//這裡的jl是記錄路徑 
				jl[t.x][t.y].y=s.y;
				mg[t.x][t.y]=1;
				Q.push(t);
			}
		}
	}
	return 0;
}
void print(int xx,int yy)//遞迴列印路徑  
{
	if (xx==0&&yy==0)
	 {
	 	cout<<xx<<" "<<yy<<endl;
	 	return ;
	 }
	 print(jl[xx][yy].x,jl[xx][yy].y);
	 cout<<xx<<" "<<yy<<endl;
}
int main()
{
	int i,j;
	for (i=0;i<5;i++)
	for (j=0;j<5;j++)
	 cin>>mg[i][j];
	cout<<bfs()<<endl;
	print(4,4);
}


相關推薦

迷宮路徑dfsbfs程式碼分析

dfs用遞迴一步步試探,在所有路徑中選出最短的一條路徑 程式碼: //0是路,1是牆 #include<iostream> #include<algorithm> using

迷宮路徑問題(BFS

別人部落格上看到的一道題:給定一個大小為N*M的迷宮,由通道(‘.’)和牆壁(‘#’)組成,其中通道S表示起點,通道G表示終點,每一步移動可以達到上下左右中不是牆壁的位置。試求出起點到終點的最小步數。(本題假定迷宮是有解的)(N,M<=100) 原地址:

BFSDFS的差別,BFS實現迷宮路徑

BFS能夠求得最短路徑,因為BFS每進行一次相當於當前的路徑長度。對於一個N*N矩陣,BFS最多執行n*n次。 深度優先搜尋相當於一個人在走迷宮,廣搜相當於是無窮人沿著不同方向走(因為每條路都同時有人走)。 DFS相當於是一個下壓棧。是先進後出的原則(如

bfs poj3984 迷宮路徑且輸出路徑

題意: 定義一個二維陣列:  int maze[5][5] = {     0, 1, 0, 0, 0,     0, 1, 0, 1, 0,     0, 0, 0, 0, 0,

BFS+優先佇列——迷宮路徑——兩種優方法比較及詳細圖解

http://blog.csdn.net/qq_36523667/article/details/78638354 這個連結裡是一道迷宮題。用到了BFS+優先佇列。 我一直百思不得其解優先佇列到底優先在哪了?我感覺和直接bfs沒啥區別?後來證明做法不一樣,思路也不一樣。

迷宮路徑長度bfs

#include<stdio.h> #include<iostream> using namespace std; struct note { int x;//橫座標 int y;//縱座標 int f;//父親在佇列中的編號,用於求輸出路

BFS解決迷宮路徑問題

迷宮問題中,有很大一部分可以用BFS來解。解決這類問題可以很大地提升能力與技巧,這篇文章是基於一個簡單例項展開來講的例題: 第一行兩個整數n, m,為迷宮的長寬。 接下來n行,每行m個數為0或1中的一個。0表示這個格子可以通過,1表示不可以。假設你現在已經在迷宮座標(1,1)

BFS迷宮路徑模板

oid pop print ios int pair 出口 最短路 bfs #include<iostream> #include<queue> #define INF 65535 using namespace std; int vis

迷宮路徑【佇列+回溯】

       求迷宮的最短路徑(0表示通路,1表示受阻) 問題:有一個迷宮,求從入口到出口的最短路徑,其中0表示通路,1表示受阻,規定向下是X軸,向右是Y軸 輸入:第一個數迷宮x軸的長度,第二個數迷宮y軸的長度,緊接著入口點的座標和出口的座標,之後

資料結構與演算法-路徑DijkstraFloy演算法

最短路徑問題一般分為兩種情況,單源最短路徑(即從一個點出發到其餘各點的最短路徑問題)和每對頂點之間的最短路徑問題。Dijkstra和Floy演算法相比之下我更喜歡Floy演算法,該演算法容易理解,思路簡潔。 兩種演算法解決最短路徑都是基於貪心的演算法,從區域性出發一點點擴充套件。 以一個

單源點路徑DijkstraBellmanford

單源點最短路徑Dijkstra和Bellmanford Dijikstra演算法精髓在於維護了兩個集合s和v,而這也是實際程式設計中實現起來比較頭疼的事情,我的做法是把每個節點都設定成一個結構體,裡面有個狀態變數,為‘s’則意味著它在S集合當中。 另外還有很多小的細節需要注意 - 在

迷宮路徑問題解析

有一個二維陣列,0表示路,-1表示牆,求其中任意兩點的最短路徑。 我們先看,怎麼求一條路徑:求兩點路徑是一個數據結構上的典型的迷宮問題,很多資料結構的書上都有介紹,解決辦法如下: 從一點開始出發,向四個方向查詢,每走一步,把走過的點的值+1(即本節點值+1),防止重複行走,並把走過的點壓入堆疊

python包NetworkX學習——路徑dijkstra_pathdijkstra_path_length

函式呼叫 dijkstra_path(G, source, target, weight='weight')#求最短路徑 dijkstra_path_length(G, source, target, weight='weight')#求最短距離 引數表

Dijkstra演算法求路徑問題完整C程式碼

<pre name="code" class="cpp">/* Dijkstra演算法求圖的最短路徑問題C程式碼 */ #include <stdio.h> #include <string.h> #include <stdlib.h> #define Ma

圖論演算法:路徑——無權路徑演算法Dijkstra演算法C++實現

前言        今天將給大家介紹的是圖論演算法中的另外一個基礎部分——最短路徑演算法;其中又分為無權最短路徑,單源最短路徑,具有負邊的最短路徑以及無圈圖等;而這次將介紹常見的兩個——無權最短路徑以及單源最短路徑。接下來就開始我們的講解吧~~原理        最短路徑演算

BZOJ4699 樹上的短路(路徑+dfs序+線段樹+堆+並查集)

i++ names 特殊 lld pop lca code span 枚舉   首先一般化的將下水道和塌陷看成一個東西。註意到在從源點出發的所有需要使用某條下水道的最短路徑中,該下水道只會被使用一次,該下水道第一個被訪問的點相同,且只會在第一個訪問的點使用該下水道。這個第一

Sicily. 迷宮路徑

Time Limit: 1sec    Memory Limit:256MB Description 有一個矩形迷宮,入口和出口都確定為唯一的,且分佈在矩形的不同邊上。 現在讓你算出最短需要走多少步,才可以從入口走到出口。 Input 共N+1行,第一行為

資料結構::迷宮(二)--棧的一個應用(求迷宮路徑

      上篇文章我們知道求解迷宮通路的方法,但是一個迷宮有時是不止一條出路,在這些出路中,我們如何找到最短的那一條,這就是我今天要說的迷宮最短路徑問題。 (此處使用的圖): 【先來分析有什麼解決方案:】 1、方法一:我們如果採用上章中遞迴的方式,將所走的路用2標記起來

迷宮路徑演算法(使用佇列)

    順便也把圖裡求迷宮最短路徑演算法貼出來,主要思想是利用佇列,採用廣度優先搜尋法,當第一次出現目的點時,中斷搜尋,並輸出路徑。程式還是主要使用的C語言,對於佇列操作我又重寫了下基本操作程式碼比如入隊、出隊等,沒辦法對C++不熟啊!!   個人認為需要說明的是:   

關於棧與遞迴求解迷宮迷宮路徑問題

一、棧實現迷宮問題: 問題描述:用一個二維陣列模擬迷宮,其中1為牆,0為通路,用棧方法判斷迷宮是否有出口,下圖為簡單模擬的迷宮: 思想: 1.首先給出入口點,如上圖入口點座標為{2,0}; 2.從入口點出發,在其上下左右四個方向試探,若為通路(值為0)時,則向前走,並將每