DFS应用

DFS：

一条路走到底

使用到的数据结构  stack（栈）   空间 O(h) （与层数成正比）

不具有最短性

BFS：

按层扩展

使用到的数据结构 queue（队列） 空间 O() （指数级）

最短路（每次走的一定是距离当前节点最近的点）

 

DFS应用——全排列

典例——AcWing 842.排列数字

给定一个整数n，将数字1~n排成一排，将会有很多种排列方法。

现在，请你按照字典序将所有的排列方法输出。

输入格式

共一行，包含一个整数n。

输出格式

按字典序输出所有排列方案，每个方案占一行。

数据范围

1≤n≤71≤n≤7

输入样例：

3

输出样例：

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

思路： 

注：每次回溯都要恢复现场！ 

#include <iostream>

using namespace std;

const int N = 10;

int n;
int path[N]; //存储当前路径上的值，回溯后当前路径会被新的路径覆盖
bool st[N];  //标记有哪些数字已经被用过

void dfs(int u)
{
    if(u == n)  //当搜索到第n个位置，说明0~n-1各位已被填满
    {
        for(int i = 0; i < n; i ++ ) //输出当前路径
        cout << path[i] << ' ';
        cout << endl;
        return ;
    }
    
    //枚举1~n这n个数，看哪个数字没被填过，可以放在位置u上
    for(int i = 1; i <= n; i ++ )
    {
        if(!st[i]) //i没有被填过
        {
            path[u] = i;  //把i填到当前位置u
            st[i] = true; //标记i已被用过
            dfs(u + 1); //继续递归下个位置
            st[i] = false; //恢复现场
        }
    }
}

int main()
{
    cin >> n;
    
    dfs(0); //从第0个位置开始
    
    return 0;
}

 深搜的本质其实是递归。

 

DFS应用——剪枝

AcWing——843.n皇后问题

n-皇后问题是指将 n 个皇后放在 n∗n 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。

现在给定整数n，请你输出所有的满足条件的棋子摆法。

输入格式

共一行，包含整数n。

输出格式

每个解决方案占n行，每行输出一个长度为n的字符串，用来表示完整的棋盘状态。

其中”.”表示某一个位置的方格状态为空，”Q”表示某一个位置的方格上摆着皇后。

每个方案输出完成后，输出一个空行。

输出方案的顺序任意，只要不重复且没有遗漏即可。

数据范围

1≤n≤91≤n≤9

输入样例：

4

输出样例：

.Q..
...Q
Q...
..Q.

..Q.
Q...
...Q
.Q..

类比全排列问题，我们把n皇后问题的几种情况全部枚举出来，判断是否合理，是ok的。

但是也可以边枚举边判断，发现矛盾，直接停止，提前判断当前的操作一定是不合法的，那么我们也就没有必要再往下搜了，这个过程就叫做剪枝。 

方法一：

枚举每一行，并检查每一列，对角线是否有“皇后”，哪个位置可以放。

#include <iostream>

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(n == u)
    {
        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;
}

方法二：

枚举每一个格子，一直到n*n，枚举完毕。

#include <iostream>

using namespace std;

const int N = 20;

int n;
char g[N][N];
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;
}