前言

今天，利用周末时间对先前算法基础课的学习进行回顾，在挑战模式中我还是卡住了，有的模板题感能写出来，有印象但就是不能完整的实现。自己惩罚自己每题敲十遍！

本篇文章是针对搜索与图论章节中的DFS与BFS模板题的再回顾与精简的总结！

一、DFS

注意搜索的顺序；当搜到叶子节点（递归结束）时就回溯，回退一步看一步

1.数字排列

【题目链接】842. 排列数字 - AcWing题库

经典全排列问题，搜索与回溯！

【核心代码如下】：

int a[N];
bool st[N];

void dfs(int u)
{
	if(u > n)//递归出口
	{
		display();
		return ;
	}
	for(int i = 1; i <= n; i ++)//搜索顺序（枚举所有可能）
	{
		if(!st[i])
		{
			a[u] = i;
			st[i] = true;
			dfs(u + 1);
			st[i] = false;//恢复现场
		}
	}
}

	dfs(1);

2.n皇后问题

【题目链接】845. 八数码 - AcWing题库

直线方程y=x+b由截距得出对角线：y-x+n防止负数出现，反对角线：y+x。从每一行开始搜索，看看哪一列上的位置合适。

【核心代码如下】：

char g[N][N];
bool col[N], ug[N], ung[N];// 列、对角线、反对角线

void dfs(int u)
{
	if(u > n)// 递归出口
	{
		display();
		return ;
	}
	for(int j = 1; j <= n; j ++)
	{
		if(!col[j] && !dg[j - u + n] && !udg[j + u])
		{
			g[u][j] = 'Q';
			col[j] = dg[j - u + n] = udg[j + u] = true;
			dfs(u + 1);
            //回溯 恢复现场
			g[u][j] = '.';
			col[j] = dg[j - u + n] = udg[j + u] = false;
		}
	}
}

二、BFS

宽度优先搜索，一层一层的搜索。如果所有边权都一样，满足最短路性质！

BFS一般框架

	1.起始点（初始状态）入队（队头）
	2.while(q.size());// 队列不为空
		拿出队头元素
		扩展队头元素
	3.队列为空，结束

1.走迷宫

【题目链接】844. 走迷宫 - AcWing题库

最短路模型，对标记数组st进行扩展，维护一个d[N][N]数组，起到记录最短作用的同时也起到标记作用！

【核心代码如下】：

typedef pair<int, int> PII;
queue<PII> q;

const int N = 110;
int g[N][N];
int d[N][N]; //存放各个点到起点的距离（最短）

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

int n, m;

int bfs()
{
    memset(d, -1, sizeof d);//初始距离全部设置为-1 表示该点未被访问过（记录距离的同时，起到了st数组的作用）
    q.push({0, 0});
    d[0][0] = 0;
    
    while(q.size())
    {
        auto t = q.front();
        q.pop();
        
        for(int i = 0; i < 4; i ++)
        {
            int a = t.first + dx[i], b = t.second + dy[i];
            if(a < 0 || a >= n || b < 0 || b >= m) continue;//越界
            if(g[a][b]) continue;//撞墙
            if(d[a][b] != -1) continue;//该点被访问过
            
            q.push({a, b});
            d[a][b] = d[t.first][t.second] + 1;//更新距离
            
        }
    }
    
    //返回到终点的最短距离
    return d[n - 1][m - 1];
}

2. 八数码

【题目链接】845. 八数码 - AcWing题库

最小步数模型：难点在于状态的切换和状态的存储，怎么将状态和最小步数关联起来等！

技巧：通常用map、unordered_map来存储记录状态，存在着key-value的对应关系，一个状态对应着它的最短距离！

坐标转换技巧：一维与二维坐标的相互转换！

假设二维坐标系有n列
一维 到 二维 ：下标：x 
	xi = x / n， yi = x % n;
二维 到 一维：(x,y)
	xi = x * n + y;

【核心代码如下】：

int bfs(string start)
{
    //定义目标状态
    string end = "12345678x";
    //定义队列和dist数组
    queue<string> q;
    unordered_map<string, int> d;
    //初始化队列和dist数组
    q.push(start);
    d[start] = 0;
    //转移方式
    int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};

    while(q.size())
    {
        auto t = q.front();
        q.pop();
        //记录当前状态的距离，如果是最终状态则返回距离
        int distance = d[t];
        if(t == end) return distance;
        //查询x在字符串中的下标，然后转换为在矩阵中的坐标
        int k = t.find('x');
        int x = k / 3, y = k % 3;

        for(int i = 0; i < 4; i++)
        {
            //求转移后x的坐标
            int a = x + dx[i], b = y + dy[i];
            //当前坐标没有越界
            if(a >= 0 && a < 3 && b >= 0 && b < 3)
            {
                //转移x
                swap(t[k], t[a * 3 + b]);
                //如果当前状态是第一次遍历，记录距离，入队
                if(!d.count(t))
                {
                    d[t] = distance + 1;
                    q.push(t);
                }
                //还原状态，为下一种转换情况做准备
                swap(t[k], t[a * 3 + b]);
            }
        }
    }
    //无法转换到目标状态，返回-1
    return -1;
}