AcWing算法基础课-第三章 搜索与图论（一）

0、本节所讲内容

        1、深度优先搜索（DFS）

        2、宽度优先搜索（BFS）

        3、树与图的存储

        4、树与图的深度优先遍历

        5、树与图的宽度优先遍历

        6、拓扑排序

一、深度优先搜索（DFS）

        深搜 尽可能的往深里边搜

        这里有两个概念：回溯 和 剪枝

        讲两个经典题：全排列问题 和 N皇后问题。

1、全排列问题

 原题链接：842. 排列数字

#include 

using namespace std;

const int N = 10;

int n;
int path[N]; // 保存路径
bool st[N]; // 记录某个数是否被用过

void dfs(int u)
{
    // 如果到叶节点时，输出
    // u == 0 时，在根节点
    // u == 1 时，在第一层
    // u == n 时，在最后一层（也就是叶子结点）
    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皇后问题（用到了剪枝概念）

原题链接：843. n-皇后问题

2.1 第一种搜索顺序

        这种方法是按行枚举的，保证每行只有一个，所以不需要 row[] 数组

#include 

using namespace std;

const int N = 20;

int n;
char g[N][N]; // 保存路径

// col[]表示同一列只能有一个，dg[]表示正对角线只能有一个，udg[]表示反对角线只能有一个
bool col[N], dg[N], udg[N];

void dfs(int u)
{
    // 如果到叶节点时，输出
    // u == 0 时，在根节点
    // u == 1 时，在第一层
    // u == n 时，在最后一层（也就是叶子结点）
    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;
}

2.2 第二种搜索顺序

#include 

using namespace std;

const int N = 20;

int n;
char g[N][N]; // 保存路径

// row[]表示同一行只能有一个，col[]表示同一列只能有一个，dg[]表示正对角线只能有一个，udg[]表示反对角线只能有一个
bool row[N], col[N], dg[N], udg[N];

void dfs(int x, int y, int s)
{
    if(y == n)
    {
        y = 0;
        x++;
    }
    
    if(x == n)
    {
        if(s == n)
        {
            for(int i = 0; i < n; i++)
                puts(g[i]);
            puts("");
        }
        return;
    }
    
    // 不放皇后
    dfs(x, y + 1, s);
    
    // 放皇后
    if(!row[x] && !col[y] && !dg[x + y] && !udg[x - y + n])
    {
        g[x][y] = 'Q';
        row[x] = col[y] = dg[x + y] = udg[x - y + n] = true;
        dfs(x, y + 1, s + 1);
        row[x] = col[y] = dg[x + y] = udg[x - y + n] = false;
        g[x][y] = '.';
    }
}

int main()
{
    cin >> n;
    
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            g[i][j] = '.';
    
    // 表示从数组的左上角开始
    dfs(0, 0, 0);
    
    return 0;
}

二、宽度优先搜索（BFS）

        宽搜 一层一层的搜

        宽搜的模板：

        

         原题链接：844. 走迷宫

前两个的比较：

        求最短路时用 BFS，比较奇怪的题（或者是对空间要求比较高的）用 DFS。

三、树与图存储（邻接矩阵、邻接表）

        树是特殊的有向图