深搜和廣搜--原理彼此的優缺點

一般來說，廣搜常用於找單一的最短路線，或者是規模小的路徑搜索，它的特點是"搜到就是最優解"， 而深搜用於找多個解或者是"步數已知（好比3步就必需達到前提）"的標題，它的空間效率高，然則找到的不必定是最優解，必需記實並完成全數搜索，故一般情況下，深搜需要很是高效的剪枝（優化）.

像搜索最短路徑這些的很顯著是用廣搜，因爲廣搜的特徵就是一層一層往下搜的，保證當前搜到的都是最優解，當然，最短路徑只是一方面的操作，像什麼起碼狀態轉換也是可以操作的。
深搜就是優先搜索一棵子樹，然後是另一棵，它和廣搜對比，有着內存需要相對較少的所長，八皇后標題就是典範楷模的操作，這類標題很顯著是不能用廣搜往解決的。或者像圖論裏面的找圈的算法，數的前序中序後序遍歷等，都是深搜

深搜和廣搜的分歧之處是在於搜索次序的分歧。

深搜的實現近似於棧，每次選擇棧頂元素往擴年夜，

廣搜則是操作了隊列，先被擴年夜的的節點優先拿往擴年夜。

搜索樹的形態：深搜層數良多，廣搜則是很寬。

深搜合適找出所有方案，廣搜則用來找出最佳方案

深搜和廣搜的分歧：

深搜並不能保證第一次碰着方針點就是最短路徑，是以要搜索所有可能的路徑，是以要回溯，標識表記標幟做了之後還要打消失蹤，是以統一個點可能被訪謁良多良多次。而廣搜因爲它的由近及遠的結點擴年夜次序，結點老是以最短路徑被訪謁。一個結點假如第二次被訪謁，第二次的路徑確定不會比第一次的短，是以就沒有需要再從這個結點向周圍擴年夜――第一次訪謁這個結點的時辰已經擴年夜過了，第二次再擴年夜只會獲得更差的解。是以做過的標識表記標幟不必往失蹤。是以統一個點至多隻可能被訪謁一次。每訪謁一個結點，與它相連的邊就被搜檢一次。是以最壞情況下，所有邊都被搜檢一次，是以時刻複雜度爲O（E）。

BFS與DFS的討論：BFS：這是一種基於隊列這種數據結構的搜索方式，它的特點是由每一個狀態可以擴展出許多狀態，然後再以此擴展，直到找到目標狀態或者隊列中頭尾指針相遇，即隊列中所有狀態都已處理完畢。
DFS：基於遞歸的搜索方式，它的特點是由一個狀態拓展一個狀態，然後不停拓展，直到找到目標或者無法繼續拓展結束一個狀態的遞歸。

優缺點：BFS:對於解決最短或最少問題特別有效，而且尋找深度小，但缺點是內存耗費量大（需要開大量的數組單元用來存儲狀態）。
        DFS：對於解決遍歷和求所有問題有效，對於問題搜索深度小的時候處理速度迅速，然而在深度很大的情況下效率不高

總結：不管是BFS還是DFS，它們雖然好用，但由於時間和空間的侷限性，以至於它們只能解決數據量小的問題。

最近剛剛接觸搜索，聽學長說搜索可以解決好多問題，就試着開始學了，話不多說，我們來看一道簡單的搜索題，對於搜索的初學者有很大的幫助。

例題鏈接：        百練-3752 走迷宮

3752:走迷宮

• 查看
• 提交
• 統計
• 提示
• 提問

總時間限制: 

1000ms 

內存限制: 

65536kB

描述

一個迷宮由R行C列格子組成，有的格子裏有障礙物，不能走；有的格子是空地，可以走。
給定一個迷宮，求從左上角走到右下角最少需要走多少步(數據保證一定能走到)。只能在水平方向或垂直方向走，不能斜着走。

輸入

第一行是兩個整數，Ｒ和Ｃ，代表迷宮的長和寬。（ 1<= R，C <= 40)
接下來是Ｒ行，每行Ｃ個字符，代表整個迷宮。
空地格子用'.'表示，有障礙物的格子用'#'表示。
迷宮左上角和右下角都是'.'。

輸出

輸出從左上角走到右下角至少要經過多少步（即至少要經過多少個空地格子）。計算步數要包括起點和終點。

樣例輸入

5 5
..###
#....
#.#.#
#.#.#
#.#..

樣例輸出

9

我們來看一下兩種方法代碼的實現：

一，DFS

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
char maps[40][40];//用於儲存迷宮中的字符 
int dp[40][40];//用於標記是否被訪問
int dir[2][4]={{1,0,0,-1},{0,1,-1,0}};//用於表示上下左右四個方向
int R,S;
int ans=1<<30;//1左移30位 
void DFS(int x,int y,int step)
{
	if(x>=R||y>=S||x<0||y<0)
	return ;           //x和y不能數組越界 
	if(x==R-1&&y==S-1)   //直到訪問到右下端結束找到最少步數 
	{
	    if(step<ans)
		ans=step;
		return ;	
	} 
	if(maps[x][y]=='#')
	return ; 
	for(int i=0;i<4;i++)
	{
		if(x+dir[0][i]>=R||y+dir[1][i]>=S||x+dir[0][i]<0||y+dir[1][i]<0)
		continue;
		if(maps[x+dir[0][i]][y+dir[1][i]]=='.'&&!dp[x+dir[0][i]][y+dir[1][i]])
		{
			dp[x+dir[0][i]][y+dir[1][i]]=1;
			DFS(x+dir[0][i],y+dir[1][i],step+1);//等同於遞歸 
			dp[x+dir[0][i]][y+dir[1][i]]=0;
		} 
	}
} 
int main()
{
	char c;
	while(cin>>R>>S)
	{
		for(int i=0;i<R;i++)
		{
			for(int j=0;j<S;j++)
			{
				cin>>c;
				maps[i][j]=c;
				dp[i][j]=0;//初始化爲0表示都未被訪問 
			}
		}
		DFS(0,0,1);
		cout<<ans<<endl; 
	} 
	return 0;
}

二，BFS

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
char maps[40][40];//用於儲存迷宮中的字符
int dp[40][40];//用於標記是否被訪問
int dir[2][4]={{1,0,0,-1},{0,1,-1,0}};//用於表示上下左右四個方向
int R,S;
int ans=1<<30;
struct node
{
    int x;
	int y;
	int step;
	node(int xx,int yy,int tt):x(xx),y(yy),step(tt){}	
};
int BFS()
{
    queue<node> que;
	que.push(node(0,0,1));
	while(!que.empty())
	{
		node temp=que.front();
		que.pop();
		for(int i=0;i<4;i++)
		{
			int tx=temp.x+dir[0][i];
			int ty=temp.y+dir[1][i];
			int tt=temp.step;
			if(dp[tx][ty])
			continue;
			if(tx<0||tx>=R||ty<0||ty>=S)
			continue;
			if(maps[tx][ty]=='#')
			continue;
			if(tx==R-1&&ty==S-1)
			{
				return tt+1;
			}
			dp[tx][ty]=1;
			que.push(node(tx,ty,tt+1));
		}
	}	
} 
int main()
{
	while(cin>>R>>S)
	{
		for(int i=0;i<R;i++)
		{
			for(int j=0;j<S;j++)
			{
				cin>>maps[i][j];
				dp[i][j]=0;
			}
		}
		int ans=BFS();
		cout<<ans<<endl; 
	}
return 0;	
}