AcWing算法 DFS 之排列数字，N-皇后问题(python,c++代码实现)

 1.DFS基础知识

深度优先搜索基础知识与原理，请参考此文章

https://blog.csdn.net/2403_89586338/article/details/146328865?fromshare=blogdetail&sharetype=blogdetail&sharerId=146328865&sharerefer=PC&sharesource=2403_89586338&sharefrom=from_linkhttps://blog.csdn.net/2403_89586338/article/details/146328865?fromshare=blogdetail&sharetype=blogdetail&sharerId=146328865&sharerefer=PC&sharesource=2403_89586338&sharefrom=from_link

2.排列数字问题

2.1 题目描述

 2.2 解题思路

运用DFS解决全排列问题，一条路搜到底

原图链接：AcWing 842. 排列数字--深度优先遍历代码+注释 - AcWing

 步骤解释:

• 用 path 数组保存排列，当排列的长度为 n 时，是一种方案，输出。
• 用 flag 数组表示数字是否用过。当 flag[i] 为 1 时：i 已经被用过，flag[i] 为 0 时，i 没有被用过。
• dfs(i) 表示的含义是：在 path[i] 处填写数字，然后递归的在下一个位置填写数字。
• 回溯：第 i 个位置填写某个数字的所有情况都遍历后， 第 i 个位置填写下一个数字。

假设有 3 个空位，从前往后填数字，每次填一个位置，填的数字不能和前面一样。

最开始的时候，三个空位都是空的： __

首先填写第一个空位，第一个空位可以填 1，填写后为：1

填好第一个空位，填第二个空位，第二个空位可以填 2，填写后为：1 2 __

填好第二个空位，填第三个空位，第三个空位可以填 3，填写后为： 1 2 3

这时候，空位填完，无法继续填数，所以这是一种方案，输出。

然后往后退一步，退到了状态：1 2 __ 。剩余第三个空位没有填数。第三个空位上除了填过的 3 ，没有其他数字可以填。

因此再往后退一步，退到了状态：1 。第二个空位上除了填过的 2，还可以填 3。第二个空位上填写 3，填写后为：1 3 __

填好第二个空位，填第三个空位，第三个空位可以填 2，填写后为： 1 3 2

这时候，空位填完，无法继续填数，所以这是一种方案，输出。

然后往后退一步，退到了状态：1 3 __ 。剩余第三个空位没有填数。第三个空位上除了填过的 2，没有其他数字可以填。

因此再往后退一步，退到了状态：1 。第二个空位上除了填过的 2，3，没有其他数字可以填。

因此再往后退一步，退到了状态： 。第一个空位上除了填过的 1，还可以填 2。第一个空位上填写 2，填写后为：2 __

填好第一个空位，填第二个空位，第二个空位可以填 1，填写后为：2 1 __

填好第二个空位，填第三个空位，第三个空位可以填 3，填写后为：2 1 3

这时候，空位填完，无法继续填数，所以这是一种方案，输出。

然后往后退一步，退到了状态：2 1 __ 。剩余第三个空位没有填数。第三个空位上除了填过的 3，没有其他数字可以填。

因此再往后退一步，退到了状态：2 。第二个空位上除了填过的 1，还可以填 3。第二个空位上填写 3，填写后为：2 3 __

填好第二个空位，填第三个空位，第三个空位可以填 1，填写后为：2 3 1

这时候，空位填完，无法继续填数，所以这是一种方案，输出。

然后往后退一步，退到了状态：2 3 __ 。剩余第三个空位没有填数。第三个空位上除了填过的 1，没有其他数字可以填。

因此再往后退一步，退到了状态：2 。第二个空位上除了填过的 1，3，没有其他数字可以填。

因此再往后退一步，退到了状态： 。第一个空位上除了填过的 1，2，还可以填 3。第一个空位上填写 3，填写后为：3 __

填好第一个空位，填第二个空位，第二个空位可以填 1，填写后为：3 1 __

填好第二个空位，填第三个空位，第三个空位可以填 2，填写后为：3 1 2

这时候，空位填完，无法继续填数，所以这是一种方案，输出。

然后往后退一步，退到了状态：3 1 __ 。剩余第三个空位没有填数。第三个空位上除了填过的 2，没有其他数字可以填。

因此再往后退一步，退到了状态：3 。第二个空位上除了填过的 1，还可以填 2。第二个空位上填写 2，填写后为：3 2 __

填好第二个空位，填第三个空位，第三个空位可以填 1，填写后为：3 2 1

这时候，空位填完，无法继续填数，所以这是一种方案，输出。

然后往后退一步，退到了状态：3 2 __ 。剩余第三个空位没有填数。第三个空位上除了填过的 1，2，没有其他数字可以填。

因此再往后退一步，退到了状态：3 。第二个空位上除了填过的 1，2，没有其他数字可以填。

因此再往后退一步，退到了状态： __。第一个空位上除了填过的 1，2，3，没有其他数字可以填。

此时深度优先搜索结束，输出了所有的方案。

2.3 c++代码

#include <iostream>

using namespace std;

const int N = 10;

int n;
int path[N];       // 从0到n-1共n个位置 存放一个排列
bool flag[N];     // 存放每个数字的使用状态 true表示使用了 false表示没使用过

void dfs(int u)
{
    if (u == n)    // 一个排列填充完成
    {
        for (int i = 0; i < n; i ++) printf("%d ",path[i]);  
        puts("");  // 相当于输出一个回车
        return;
    }

    for (int i = 1; i <= n; i ++)
    {
        if (!flag[i])
        {
            path[u] = i;       // 把 i 填入数字排列的位置上
            flag[i] = true;   // 表示该数字用过了 不能再用
            dfs(u + 1);        // 这个位置的数填好 递归到右面一个位置
            flag[i] = false;  // 恢复现场 该数字后续可用
        }
    }
    // for 循环全部结束了 dfs(u)才全部完成 回溯
}

int main()
{
    scanf("%d", &n);
    dfs(0);    // 在path[0]处开始填数
    return 0;
}

2.4 python代码

n=int(input())
path=[0 for _ in range(n)]
flag=[False for _ in range(n+1)]
def dfs(u):
    if u==n:
        for i in range(n):
            print(path[i],end=' ')
        print()
        return 0   
        #这一层dfs结束，但上一层的dfs继续运行，退回到上一层，进行回溯
    for j in range(1,n+1):
        if not flag[j]:
            path[u]=j
            flag[j]=True   #保证下一个数与上一个数不同
            dfs(u+1)
            flag[j]=False  #回溯标记
dfs(0)  #第0个位置开始(0索引)
            
    

3.N-皇后问题

3.1 题目描述

输入数据：

4

输出数据：

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

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

 3.2 解题思路

核心思路：

• 函数名：void dfs(int r): 深度优先遍历函数。参数r：从第r行开始放棋子，处理第r行。
• 递归结束判定：见代码，当 r == n的时候，说明应该处理第 n行了，也代表第 0~n-1行放好棋子，也就是整个棋盘放好了棋子，也就是得到了一种解，也就是递归结束。
• 第r行，第i列能不能放棋子：用数组dg udg cor 分别表示：点对应的两个斜线以及列上是否有皇后。
• dg[i + r] 表示 r行i列处，所在的对角线上有没有棋子，udg[n - i + r]表示 r行i列处，所在的反对角线上有没有棋子，cor[i]表示第i列上有没有棋子。如果 r行i列的对角线，反对角线上都没有棋子，即!cor[i] && !dg[i + r] && !udg[n - i + r]为真，则代表 r行i列处可以放棋子。

疑难解释：
对角线 dg[u+i]，反对角线udg[n−u+i]中的下标 u+i和 n−u+i 表示的是截距 

• 反对角线 y=x+b, 截距 b=y−x，因为我们要把 b 当做数组下标来用，显然 b不能是负的，所以我们加上 +n（实际上+n+4,+2n都行），来保证是结果是正的，即 y - x + n
• 而对角线 y=−x+b, 截距是 b=y+x，这里截距一定是正的，所以不需要加偏移量

原图链接：AcWing 843. n-皇后问题--图解+代码注释 - AcWing

3.3 c++代码

#include <iostream>
using namespace std;

const int N = 11;

char q[N][N];//存储棋盘
bool dg[N * 2], udg[N * 2], cor[N];//点对应的两个斜线以及列上是否有皇后
int n;
void dfs(int r)
{
    if(r == n)//放满了棋盘，输出棋盘
    {
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < n; j++)
                cout << q[i][j];
            cout << endl;
        }
        cout << endl;
        return;
    }

    for(int i = 0; i < n; i++)//第 r 行，第 i 列 是否放皇后
    {
        if(!cor[i] && !dg[i + r] && !udg[n - i + r])//不冲突，放皇后
        {
            q[r][i] = 'Q';
            cor[i] = dg[i + r] = udg[n - i + r] = 1;//对应的 列， 斜线 状态改变
            dfs(r + 1);   //处理下一行
            cor[i] = dg[i + r] = udg[n - i + r] = 0;//恢复现场
            q[r][i] = '.';
        }
    }
}

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

3.4 python代码

n=int(input())
col=[False for _ in range(n)]
dg=[False for _ in range(n*2)]  #主对角线列表
udg=[False for _ in range(n*2)] #副对角线列表
p=[['.' for _ in range(n)] for _ in range(n)] #生成棋盘

def dfs(r):
    if r==n:
        for i in range(n):
            for j in range(n):
                print(p[i][j],end='')
            print()
        print()
        return
    for c in range(n): #一条对角线上的坐标,(x+y)的值是不变的
        if not col[c] and not dg[r+c] and not udg[r-c+n]:
            p[r][c]='Q'
            col[c]=dg[r+c]=udg[r-c+n]=True
            dfs(r+1)
            col[c]=dg[r+c]=udg[r-c+n]=False
            p[r][c]='.'
dfs(0)