DFS和BFS

DFS(深度优先搜索)：

DFS是一个不断探查和回溯的过程，从根节点开始，每探查一个节点就将该点访问位置为true，接着在该点所有下位节点中，找出尚未访问过的一个，将其作为下个探查的目标，接着对这个目标进行相同的操作，直到没有下位节点，然后退回到前一个节点，继续探查为false的其他下位节点，不断重复，直到把每一条路线走过或是找到符合题目要求的解。

大致dfs模板：

void dfs(int u)
{

    if(u==n)//已达到当前路线的最后一个节点
    {
        for(int i=0;i<=n;i++)
        {循环内按题目要求进行输出}
        return;
    }

    for(int i=1;i<=n;i++)
        if(当前节点状态为未被探查过或符合答案性质)
        {
            修改当前节点状态；
            dfs（u+1);//继续递归下一节点
            恢复当前节点状态；（此步骤一般与修改有对称性，具体因题而异）
        }

}

举两个例子：

1.输入n，要求输出从1到n之间整数的所有排列形式

#include<iostream>
using namespace std;
const int N=10;
int n;
int path[N];
bool st[N];

void dfs(int u)
{
    if(u==n)
    {
        for(int i=0;i<=n;i++)
        printf("%d ",path[i]);
        putd("");
        return;
    }

    for(int i=1;i<=n;i++)
        if(!st[i])
        {
            path[u]=i;
            st[i]=true;
            dfs(u+1);
            st[i]=false;
        }
}   

int main()
{
    cin>>n;
    dfs(0);
    return 0;
}

path[x]表示排列在x处的数，st[x]表示x节点的查询状况。

2.n皇后问题：

#include<iostream>
using namespace std;
const int N=20;
int n;
char g[N][N];
bool col[N],dg[N],udg[N];

void dfs(int u)
{
    if(u==n)
    {
        for(int i=0;i<=n;i++)
        puts(g[i]);
        putd("");
        return;
    }

    for(int i=1;i<=n;i++)
        if(!col[i]&&!dg[u+i]&&!udg[n-u+i])
        {
            g[u][i]='Q';
            col[i]=dg[u+i]=udg[n-u+i]=ture;
            dfs(u+1);
            col[i]=dg[u+i]=udg[n-u+i]=false;
            g[u][i]='.';
        }
}   

int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            g[i][j]='.';
    dfs(0);
    return 0;
}

g表示当前点是否为皇后，col用于记录当前点所在纵列上是否已有皇后，dg用于记录当前点所在的从左上到右下的斜线上是否已有皇后，udg用于记录当前点所在的从右上到左下的斜线上是否已有皇后。

DFS没有标准的模板，重要的是逐条判断的解题思路，一般用于要统计每一种情况的时候。

---------------------------------------------------------------------------------------------------------------------------------------------------------

BFS(宽度优先搜索)：

BFS是一个逐层遍历的过程，每探查一步就将该步访问位置为true，接着在该点所有同层邻接节点中，找出尚未访问过的一个，将其作为下个探查的目标，接着还是对该节点（而不是所选择的目标）剩下的未访问的点选择一个，作为下一个探查的目标，直到没有邻接点为止。这些探测过的点存放于一个队列中，当该节点没有邻接节点时，取出队首的点进行相同的操作，直到队列为空。

例题模板：

求在一个NxM的地图中从（0，0）到（n-1，m-1）所需的最少步骤

#include<iostream> 
#include<cstring>
#include<algorithm>
using namespace std;
typedef pair<int,int> PII;
const int N=110;
int n,m;
int g[N][N];
int d[N][N];
PII q[N*N];

int bfs()
{
	int hh=0,tt=0;
	q[0]={0,0};
	memset(d,-1,sizeof d);
	d[0][0]=0;
	int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};
	while(hh<=tt)
	{
		auto t=q[hh++];
		for(int i=0;i<4;i++)
		{
			int x=t.first+dx[i],y=t.second+dy[i];
			if(x>=0&&x<n&&y>=0&&y<m&&g[x][y]==0&&d[x][y]==-1)
			{
				d[x][y]=d[t.first][t.second]+1;
				q[++tt]={x,y};
			}
		}
	}
	return d[n-1][m-1];
}

int main()
{
	cin>>n>>m;
	for(int i=0;i<n;i++)
		for(int j=0;j<m;j++)
			cin>>g[i][j];
			
	cout<<bfs()<<endl;
	return 0;
}

g函数用于储存地图情况，d函数表示每个点距离起点的步数。

运行思路：每一步的所有选择都记录，直到把每一种走法能达到的位点都判断后才继续走下一步，这样就能在第一次到达终点的时候就停止，从而得出最短步数。

总结：DFS便于要遍历所有路线的题，BFS便于查找最短路径。