Acwing基础算法学习：搜索与图论（1）(dfs、bfs)

第一次写博客，记录一下昨日的学习成果，也算对于自己学习知识的一种温习吧。

DFS：

Dfs又被称为深度优先搜索。换句话说，就是不撞南墙心不死，一路走到黑。深搜大多数用于充满暴力美学的题目，如列举子序列，子集合等。代表题型有N皇后(843)、排序数字(842)。遍历产生的树形结构来找到所有的答案(答案一般处于叶节点)。该方法通常和剪枝、回溯并用来减少时间复杂度。

排序数字

 下面是我个人的代码：

const int N = 10;
int n,idx;
int q[N]; //数组模拟队列
int st[N]; //用于确认数字n是否被使用

void dfs()
{
    if(idx == n) 
    {
        for(int i=1;i<=idx;i++) printf("%d ",q[i]);
        printf("\n");
        return;
    }
    for(int i=1;i<=n;i++)
    {
        if(!st[i])
        {
            q[++idx] = i;
            st[i]++;
            dfs();
            st[i] = 0;
            idx--;
        }
    }
}

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

关注一下dfs方法中for循环内部的操作：回溯的运用

 st[i]++;
 dfs();
 st[i] = 0;

 N皇后

 

代码部分

#include <iostream>

using namespace std;

const int N = 20;
int n;
char b[N][N]; //存储棋盘
bool col[N],dg[N],udg[N]; 
//col 存储当前列是否有皇后、 dg为正对角线是否有皇后、 udg为反对角线是否有皇后

void dfs(int c)
{
    if(c == n)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
                printf("%c",b[i][j]);
            puts("");
        }
            
        puts("");
        return;
    }
    
    for(int i = 0;i < n;i ++)
    {
        if(!col[i] && !dg[i+c] && !udg[n+c-i])
        {
            b[c][i] = 'Q';
            col[i] = dg[i+c] = udg[n+c-i] = true;
            dfs(c+1);
            b[c][i] = '.';
            col[i] = dg[i+c] = udg[n+c-i] = false;
        }
    }
}

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

 当然可以看到，在dfs的for循环中也涉及到了回溯的部分。但是这道题目也包含了剪枝的思想，即每一次遍历棋盘上一行中的某个位置之后，直接进入下一行进行遍历而不需要再同行搜索（其实这也就是深搜的思想）。原因就是当前行已经占有皇后，这一行再放入皇后一定不符合题意。故直接省去同行继续遍历的想法，达到剪枝的目的。

同时每次放入皇后的时候，需要判断当前列是否有皇后，对角线呢，反对角线呢？这是根据y总提供的模板修改而来，我觉得也是非常的精到。

if(!col[i] && !dg[i+c] && !udg[n+c-i])

 还有一点要注意的就是对角线和反对角线数组的维护，这里就不多赘述，想要了解深究可以画画坐标图，一目了然。

col[i] = dg[i+c] = udg[n+c-i] = true;

 BFS:

宽搜，也叫广度优先遍历。与深搜的区别要提一提，使用的时候有所选择。首先，宽搜的时间复杂度高，因为要一个个节点层次遍历。其次，宽搜需要维护一个队列来满足宽搜的需要。还有也是最重要的一点，宽搜可以用来解决最短路问题，这是深搜不具备的。

涉及的代表题目 走迷宫(844)、八数码(845)

走迷宫

 代码部分

#include <iostream>

using namespace std;

const int N = 110;
typedef pair<int, int> PII; //迷宫中每一个点用pair存储
int n,m;
int b[N][N],p[N][N]; //b用于存储迷宫 p用于存储迷宫中各个点到初始点的距离
PII q[N*N]; //用于迷宫中存储每一个点的队列，辅助宽搜

int bfs()
{
    int hh = 0,tt = -1; //hh 为队头， tt为队尾
    q[++tt] = {0,0};
    int dx[] = {0,1,-1,0}, dy[] = {1,0,0,-1};
    while(tt >= hh)
    {
        auto t = q[hh++];
        for(int i=0;i<4;i++)
        {
            int x = dx[i] + t.first, y = dy[i] + t.second;
            if(b[x][y] != 1 && p[x][y] == 0 && x >= 0 && y >=0 && x < n && y < m)
            {
                q[++tt] = {x,y};
                p[x][y] = p[t.first][t.second] + 1;
            }
        }
    }
    
    
    return p[n-1][m-1];
}

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

while(tt >= hh)
    {
        auto t = q[hh++];
        for(int i=0;i<4;i++)
        {
            int x = dx[i] + t.first, y = dy[i] + t.second;
            if(b[x][y] != 1 && p[x][y] == 0 && x >= 0 && y >=0 && x < n && y < m)
            {
                q[++tt] = {x,y};
                p[x][y] = p[t.first][t.second] + 1;
            }
        }
    }

宽搜的很重要的一个步骤，就是关于节点入队的部分。如果节点当前位置能够行动，并且x、y坐标合法，并且当前节点没有走过(p矩阵对应的值为0)，那么就把当前节点入队。依次遍历上下左右四个方向。这边运用一个dx、dy向量来表示向上向下向左向右四个操作，如果想要进行操作，只需要让x += dx, y += dy即可这一部分也是借鉴y总的思想，很方便。