AcWing.算法基础课-第三章 搜索与图论

DFS

        dfs是一种深度优先搜索算法，他秉持着不装南墙不回头的性格，一直会沿着当前道路走到头才会换道路，对于方案数问题我们一般用dfs的方式去枚举并判断合法性。主要递归实现搜索过程。

        而一般在深度优先搜索算法中往往伴随着两个关键操作，回溯和剪枝；

        回溯就到达终点后一层一层回到上个状态，选择不同的道路，这里我们我进行回复现场的操作，就是把动过的东西还原回去，不影响下次dfs.

        剪枝，顾名思义减去不用的枝条也就是把那些当前看来已经不可能的选项排除掉，剪枝的方式有很多，例如：最优性剪枝（如果当前结果没有之前的优秀那么就直接删除这个道路）....

dfs模板

void 函数名（参数）//回溯算法的参数一般比较多，要根据具体情况进行分析
{
    if(终止条件)
      {
         收集最后节点结果
         return  ;
      }
//单层搜索的逻辑:
    for(集合的元素）//遍历的是集合里的每一个元素，也可能是集合节点的子节点个数
      {
          处理节点
          递归函数
          回溯操作（撤销处理节点的操作）
      }
    return ；

例题讲解

排列数字

//遍历每个数字如果没有用过就添加进答案数组，一组弄完后回复现场即可（取消标记数字）
#include<bits/stdc++.h>
using namespace std;

const int N = 1e6+10;
int n; 
int a[N],v[N];

void dfs(int x){
    if(x == n){
        for(int i = 0; i < n; i++) cout << a[i] << " ";
        cout << endl;
    }
    for(int i = 1; i <= n; i++){
        if(!v[i]){
            v[i] = 1; //标记
            a[x] = i; //加入答案
            dfs(x+1);
            v[i] = 0; //回复现场
        }
    }
}

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

n-皇后问题

//n皇后问题是dfs的经典问题。解决方法也有很多，这里推荐比较经典的方式
//主要用数学方位标记，判断如果放这个点那么横纵，正对角线，反对角线有没有冲突。
#include<bits/stdc++.h>
using namespace std;

const int N = 1e2+10;
int n;
char g[N][N];
bool col[N],dg[N],udg[N];  //col横纵，dg正对角线，udg反对角线

void dfs(int u){
    if(u == n){
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++) cout << g[i][j];
            cout << endl;
        }
        cout << endl;
    }
    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] = 1; 
            dfs(u+1);
            //恢复现场
            col[i] = dg[u+i] = udg[n-u+i] = 0; 
            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

        广度优先搜索（BFS），顾名思义一层一层扩散式遍历，主要是队列实现搜索过程，把当前状态下面所以状态全算出来再进行下一层节点遍历，由于这种一层层搜索的过程，所以它常用来解决最短路径问题，可证明这样做第一次遍历到一定是最短的。

bfs模板

Q.push(初始状态); //将初始状态入队
while(!Q.empty()){
    auto u = Q.front(); q.pop();
    for(枚举所有可扩展的点) //找到u所有可达状态v
        if(是合法的) //v需要满足一些条件
            Q.push(v);
            维护其他信息.....
}

例题讲解

走迷宫

#include<bits/stdc++.h>
using namespace std;

typedef pair<int,int> PII;
const int N = 1e3+10;
int n,m;
int g[N][N],dist[N][N]; //g地图，dist步数
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1}; //方向数组，控制每次行走方向


int bfs(){
    memset(dist,-1,sizeof dist); //初始化，用于判断此点是不是第一次到
    dist[1][1] = 0;
    queue<PII> q;
    q.push({1,1});
    while(!q.empty()){
        auto t = q.front(); q.pop();
        for(int i = 0; i < 4; i++){
            //找到扩展新点
            int sx = t.first+dx[i];
            int sy = t.second+dy[i];
            if(sx >= 1 && sy >= 1 && sx <= n && sy <= m && g[sx][sy] == 0 && dist[sx][sy] == -1){
                dist[sx][sy] = d