在解决一些较复杂的问题时候，只会一些很简单的算法如：贪心，简单枚举，模拟，分治...是远远不够的，还需要了解一些除此之外的算法，这篇文章将带你了解搜索基础：dfs（下面简称深搜）与bfs（下面简称广搜）。
什么是深度优先搜索与宽/广度优先搜索
深搜和广搜都是以一定的顺序遍历整张图的算法，算法上的搜索主要包括两类：深搜与广搜，狭义的深搜还包括 A*（A Star) 和 IDA* ,深搜的搜索思想是从一个结点开始不断下探，直到无路可走在进行回溯，而广搜则是将此层遍历完后再搜索先一层，例如下面这棵树：
使用深搜的遍历顺序是 1-2-5-3-6-7-4
而使用广搜则是 1-2-3-4-5-6-7
深度优先搜索
深度优先搜索本质是枚举的一种，和普通枚举的区别是普通枚举有明确的层次，而搜索则没有这一点，因此需要用递归实现，深搜的模板如下：
void dfs(需要的数据)
{
if(符合条件）//剪枝
{
return；
}
if(找到了想要的数据)
{
处理数据
return；
}
for(遍历所有情况）
{
if(符合条件）
{
标记已搜索
dfs(...) //继续搜索
回溯
}
}
例题： 骑士的移动
题目描述：
输入8*8的国际象棋棋盘上的2个格子（列：a-h，行：1-8），求马至少多少步从起点（键盘输入的第一个位置）跳到终点（键盘输入的第二个位置）。
解析：
从题目中可以看出是棋盘问题，棋盘类的题目一般用搜索或者动态规划来解决，这一题则应使用搜索来解决，但最短路问题最好使用bfs,但用dfs更能体现简直所在。
首先需要解决输入的为字符串的问题，字母可以使用： 字母 -'a'+1 的方式转换为数字，数字则用： 数字-'0' 来解决。
接着套上模板写出代码：
错误代码示范（超时）
#include<bits/stdc++.h>
using namespace std;
string a,b;
int ans=1000000,ax,ay,bx,by;
int ne[8][2]={{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2},{-1,-2},{-2,1}};
int vis[25][25]={0};
void dfs(int x,int y,int n)
{
if(x==bx&&y==by)
{
ans=min(ans,n);
return;
}
for(int i =0;i<8;i++)
{
int nx=x+ne[i][0];
int ny=y+ne[i][1];
if(nx>=1&&nx<=8&&ny>=1&&ny<=8&&vis[nx][ny]==0)
{
vis[nx][ny]=1;
dfs(nx,ny,n+1);
vis[nx][ny]=0;
}
}
}
int main()
{
while(cin>>a>>b)
{
memset(vis,0,sizeof(vis));
ans=10000000;
ax=a[0]-'a'+1;
ay=a[1]-'0';
bx=b[0]-'a'+1;
by=b[1]-'0';
dfs(ax,ay,0);
cout<<"To get from "<<a<<" to "<<b<<" takes "<<ans<<" knight moves."<<endl;
}
return 0;
}
超时原因是因为这一题用dfs时间复杂度太高，简直优化不到位，可以这样解决：如果当前找到的答案大于已找到的答案则直接返回：
正确代码示例：
#include<bits/stdc++.h>
using namespace std;
string a,b;
int ans=1000000,ax,ay,bx,by;
int ne[8][2]={{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2},{-1,-2},{-2,-1}};
int vis[25][25]={0};
void dfs(int x,int y,int n)
{
if(x>=1&&y<=8&&y>=1&&y<=8&&n<ans)
{
if(x==bx&&y==by)
{
ans=n;
}
for(int i =0;i<8;i++)
{
int nx=x+ne[i][0];
int ny=y+ne[i][1];
if(nx>=1&&nx<=8&&ny>=1&&ny<=8&&vis[nx][ny]==0)
{
vis[nx][ny]=1;
dfs(nx,ny,n+1);
vis[nx][ny]=0;
}
}
}
}
int main()
{
while(cin>>a>>b)
{
memset(vis,0,sizeof(vis));
ans=10000000;
ay=a[0]-'a'+1;
ax=a[1]-'0';
by=b[0]-'a'+1;
bx=b[1]-'0';
dfs(ax,ay,0);
cout<<"To get from "<<a<<" to "<<b<<" takes "<<ans<<" knight moves."<<endl;
}
return 0;
}
完美AC！
广度优先搜索
一般涉及到最单路问题是，使用bfs的效率远高于dfs，因为广度优先搜索是一层一层的遍历，所以不需要回溯。
bfs靠队列实现，其原理是，遍历这一层的所有点，当符合条件时，入队将数据存储起来.
什么是队列
队列是 STL 中一种先进先出的数据结构 ，使用时应带上头文件<queue>.
队列主要有以下操作：
1.建立队列： queue<数据类型> 队列名，如 queue<int> q;
2.获取队首元素 ： 队列名.front(),如 q.front();
3.弹出对手元素：队列名.pop(),如 q.pop();
4.判断队列是否为空：队列名.empty(),如 q.empty();
下面是bfs的模板：
void dfs(int x)
{
queue<int> q;
q.push(x);
int u;
标记起始位置已访问
while(!q.empty())
{
u=q,front();
q.pop();
处理数据
for(遍历所有情况）
{
if(符合条件）
{
入队
标记已访问
}
}
}
}
例题：填涂颜色
题目描述：
由数字 0 组成的方阵中，有一任意形状闭合圈，闭合圈由数字 1 构成，围圈时只走上下左右 4 个方向。现要求把闭合圈内的所有空间都填写成 2
解析：
很明显的一道bfs 题目（也可以用dfs),只需要找到封闭的换里面的一个 0 然后进行 广搜 就可以了，但要怎么去找呢？ 通过观察样例可以看出，按照从上到下，从左到右的顺序遍历矩阵，第一个 1 右下角的 0 就是环里面的数，这样一来代码就很容易实现了：
#include<bits/stdc++.h>
using namespace std;
int n,m[35][35],vis[35][35]={0},a[35][35];
int ne[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
void bfs(int x,int y)
{
queue<int> q;
q.push(x);
q.push(y);
vis[x][y]=1;
m[x][y]=2;
int u,v;
while(!q.empty())
{
u=q.front();
q.pop();
v=q.front();
q.pop();
m[u][v]=2;
for(int i = 0;i<=3;i++)
{
int a=u+ne[i][0];
int b=v+ne[i][1];
if(a>=1&&a<=n&&b>=1&&b<=n&&vis[a][b]==0&&m[a][b]==0)
{
q.push(a);
q.push(b);
vis[a][b]=1;
}
}
}
}
int main()
{
scanf("%d",&n);
for(int i = 1;i<=n;i++)
for(int j = 1;j<=n;j++)
{
cin>>m[i][j];
}
for(int i = 1;i<=n;i++)
{
for(int j = 1;j<=n;j++)
{
if(m[i][j]==1)
{
bfs(i+1,j+1);
break;
}
}
break;
}
for(int i = 1;i<=n;i++)
{
for(int j = 1;j<=n;j++)
{
cout<<m[i][j]<<" ";
}
cout<<endl;
}
return 0;
}