寒假打卡第四天——BFS与DFS

DFS算法 （栈）

深度优先搜索，比较执着，沿一条路走到底，当走到无路可走时，回溯，从而达到全部搜索完成。
举个栗子：

如果从A开始搜索，
A先进入栈：A
A出栈时，A的邻接节点B，C，D进入栈：B C D
D出栈时，D的邻接节点A C G中G进入栈：B C G
G出栈时，G的邻接节点C D 都已进入：B C
C出栈时，C的邻接节点A D G F中F进入栈：B F
F出栈时，F的邻接节点B C都已进入：B
B出栈时，B的邻接节点A E F中E进入栈：E
E出栈
结果：A D G C F B E

BFS算法（队列）

宽度优先搜索——一层一层搜
举个栗子
就看DFS的图吧。
A先进入队列：A
A出队列时，A的邻接节点B C D 进入队列：B C D
B出队列时，B的邻接节点A E F中E F进入队列：C D E F
C出队列时，C的邻接节点A D G F中G进入队列：D E F G
D出队列时，D的邻接节点A C G 都已进入：E F G
E出队列时，E的邻接节点B已进入：F G
F出队列时，F的邻接节点B C都已进入：G
G出队列
结果：A B C D E F G
典型例题

DFS

1.全排列
全排列问题大家应该都知道，简单描述一下吧，比如给你一个3，让你列举3的全排列
1，2，3
1，3，2
2，1，3
2，3，1
3，1，2
3，2，1
额，咋做呢 ？
我们用一个数组，一个小孩现在站在第0个下标的位置，看看1有没有被用到
1
再到下一个位置，下标是1，看看2没有被用
1，2
再到下一个位置，下标是2，看看3没有被用
1，2，3
小孩已经到了下标是3的位置了，输出结果1，2，3
回溯，回到上一个位置，恢复现场
1，2
再回溯到上一位置，下表是0，恢复现场
1
再到下一个位置，下标是1，2已经被用过了，看看3有没有被用
1，3
再到下一个位置，看看2有没有被用
1，3，2
下一个位置，下标是3，输出结果1，3，2
到下标是0的位置，按照这个顺序来

#include<iostream>
#include<algorithm>
using namespace std;
const int N=100;
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]);
		puts("");
		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;
}

2，八皇后问题
哎，八皇后问题是啥呀，来喽，八皇后问题是说，将n个皇后放在n*n个国际象棋棋盘上，你动动你的小脑袋，让这n个皇后不能处于同一行，同一列，或同一条斜线上。
第一种方法：已知每一行都有一个皇后，那么我们知需要把每一行的皇后所处的每一列全排列找出适合题目的方案，输出就行了
输入输出样例
4
.Q…
…Q
Q…
…Q.

…Q.
Q…
…Q
.Q…

#include <iostream>
#include <algorithm>
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]);
		puts("");
		return;
	}
	for(int i=0;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]=true;
			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;
}

BFS

有一个nm的迷宫，用1表示不可以走，0表示可以走，走时只能是上下左右四个方向，有一个人位于（1，1）位置，要走到右下角（nm）的位置，求至少移动多少次，举个栗子
5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出
8

#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;
}

使用stl

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 110;

int n, m;
int g[N][N], d[N][N];//g[N][N]用于存储数据矩阵  d[N][N]用于存储距离
int bfs()
{
    queue<PII> q;

    memset(d, -1, sizeof d);     
    d[0][0] = 0;
    q.push({0, 0});     

    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        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.push({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;
}