DFS和BFS

DFS关键词是深度，是一种枚举所有完整路径以遍历所有情况的搜索方法，也被叫做盲目搜索。在搜索过程中，DFS先选择一条路走下去，直到碰到死胡同，就退回上一个结点，在这个结点选择另一条路走，如果还不通，就再返回到上一个结点，再换一条路走，如果该结点所有路都不通，就再返回到上一个结点，循环往复，直到找到出路为止。DFS可以用栈来实现，也常用到递归。

BFS关键词是广度，因其时间复杂度太高，也被称为暴力搜索。与DFS不同，BFS在搜索过程中在遇到岔路口时，总是先访问从该岔道口能直接到达的所有结点(DFS是先访问其中一条)，BFS常用队列来实现

适合题型:

DFS:适合找解是否存在的问题、适合搜索全部的解，找最优解基本不会用

BFS:适用于找最优解问题，比如求最少步数的解，最少交换次数的解

模板:

DFS:参考

https://mbd.baidu.com/ma/s/rw2rDUa8

BFS:参考

https://mbd.baidu.com/ma/s/Pl2N9K21

列举几道题来理解DFS和BFS的用法

一.DFS

1.背包问题

题意:

有n件物品，每件物品的重量为w[i]，价值为c[i]。现在需要选出若干件物品放入一个容量为v的背包中，使得在选入背包的物品重量和不超过容量v的前提下，让背包中的物品的价值之和最大，求最大价值。(1<=n<=20)

分析:

该题对每一种物品都有选和不选两种选择，相当于是岔路口，而当总重量达到或超过v时，就相当于到达了死胡同，就要返回上一个结点，再作出另一种选择，如此循环，找到最后的解。

代码:

#include<bits/stdc++.h>
using namespace std;
int ans=0;
int n,v,w[30],c[30],i;
void dfs(int index,int sumw,int sumc)
{
if(index==n)
return;
dfs(index+1,sumw,sumc);//不选第index件物品
if(sumw+w[index]<=v)
{
if(sumc+c[index]>ans)
ans=sumc+c[index];
dfs(index+1,sumw+w[index],sumc+c[index]);

//选第index件物品
}
}
int main()
{
cin>>n>>v;
for(int i=0;i<n;i++)
cin>>w[i];
for(int i=0;i<n;i++)
cin>>c[i];
dfs(0,0,0);
cout<<ans<<endl;
    return 0;
}

2.洛谷p1164

分析:该题因为要搜索全部解，所以可以用DFS做，选菜就是岔路口，当选择菜品的总钱数大于等于身上的钱时就碰到了死胡同

代码:

#include<bits/stdc++.h> 
using namespace std;
int n,m,d,a[110]={0},ans=0,b[110]={0};
void dfs(int index,int sump)
{
if(sump>m)
return;
if(sump==m)
{
ans++;
return;
}
for(int i=index+1;i<=n;i++)
{
if(b[i]==0)
{
b[i]=1;
dfs(i,sump+a[i]);
b[i]=0;
}
}
}
int main()
{
ios::sync_with_stdio(false);
cin>>n>>m;
for(int i=1;i<=n;i++)
cin>>a[i];
dfs(0,0);
cout<<ans;
    return 0;
}

3.洛谷p1605

#include<bits/stdc++.h> 
using namespace std;
int n,m,t,sx,sy,fx,fy;
int x[]={1,0,-1,0};
int y[]={0,1,0,-1};
//x[]，y[]表示上下左右四个方向走
int ans=0;
int v[25][25];
int a[25][25],b,c;
bool judge(int x,int y)
{
if(x>=1&&x<=n&&y>=1&&y<=m&&v[x][y]==0&&a[x][y]!=2)
return 1;
return 0;
}
void dfs(int sx,int sy)
{
if(sx==fx&&sy==fy)
{
ans++;
return;
}
for(int i=0;i<4;i++)
{
int nx=sx+x[i];
int ny=sy+y[i];
if(judge(nx,ny))
{
v[nx][ny]=1;//表示该点已用过
dfs(nx,ny);//走下一步
v[nx][ny]=0;
}
}
}
int main()
{
cin>>n>>m>>t;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
a[i][j]=0;
//让整个迷宫的点用0表示
cin>>sx>>sy>>fx>>fy;
while(t--)
{
cin>>b>>c;
a[b][c]=2;
//障碍点用2表示
}
v[sx][sy]=1;
//表示点(sx,sy)已经走过
dfs(sx,sy);
cout<<ans;
    return 0;
}

二.BFS

1.题目背景描述：
农夫约翰有一片 N∗M 的矩形土地。
最近，由于降雨的原因，部分土地被水淹没了。
现在用一个字符矩阵来表示他的土地。
每个单元格内，如果包含雨水，则用”W”表示，如果不含雨水，则用”.”表示。
现在，约翰想知道他的土地中形成了多少片池塘。
每组相连的积水单元格集合可以看作是一片池塘。
每个单元格视为与其上、下、左、右、左上、右上、左下、右下八个邻近单元格相连。
请你输出共有多少片池塘，即矩阵中共有多少片相连的”W”块。
输入格式
第一行包含两个整数 N 和 M。
接下来 N 行，每行包含 M 个字符，字符为”W”或”.”，用以表示矩形土地的积水状况，字符之间没有空格。
输出格式
输出一个整数，表示池塘数目。
数据范围
1≤N,M≤1000
输入样例：
10 12
W…WW.
.WWW…WWW
…WW…WW.
…WW.
…W…
…W…W…
.W.W…WW.
W.W.W…W.
.W.W…W.
…W…W.
输出样例：
3

思路:从第一行第一列开始遍历，用数组st[1010][1010]来记录该点是否被遍历过，如果是，则跳过，选择合适的点放入队列，以该点为中心向8个方向扩散，对于不合适的点continue。

代码：

#include<bits/stdc++.h> 
using namespace std;
int n,m,cnt=0;
char s[1010][1010];
int dx[]={1,-1,0,0,1,-1,1,-1};
int dy[]={0,0,1,-1,1,-1,-1,1};
bool st[1010][1010];
void bfs(int a,int b)
{
queue<pair<int,int>> q;
q.push({a,b});
st[a][b]=1;
while(!q.empty())
{
auto t=q.front();
q.pop();
a=t.first;
b=t.second;
for(int i=0;i<8;i++)
{
int na=a+dx[i];
int nb=b+dy[i];
if(na<0||na>=n||nb<0||nb>=m)
continue;
if(s[na][nb]=='.'||st[na][nb])
continue;
st[na][nb]=true;
q.push({na,nb});
}
}
}
int main()
{
int i,j;
cin>>n>>m;
for(i=0;i<n;i++)
for(j=0;j<m;j++)
cin>>s[i][j];
for(i=0;i<n;i++)
for(j=0;j<m;j++)
if(s[i][j]=='w'&&st[i][j]==0)
{
bfs(i,j);
cnt++;
}
cout<<cnt<<endl;
    return 0;
}

知识补充:

关键字auto