算法刷题总结—DFS

最新推荐文章于 2024-03-15 21:07:41 发布

迷你猪@123

最新推荐文章于 2024-03-15 21:07:41 发布

阅读量146

点赞数

文章标签：深度优先算法

本文链接：https://blog.csdn.net/qq_54780782/article/details/130663862

版权

文章介绍了使用深度优先搜索（DFS）策略解决排列问题和N皇后问题。对于排列问题，通过DFS按字典序输出1到n的所有排列。而对于N皇后问题，提供了两种DFS解法，分别是从每个格子开始和从每一行开始遍历，确保皇后不处于同一行、列或对角线上。文章还比较了两种方法的运行效率。

摘要由CSDN通过智能技术生成

1.排列问题

问题描述

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

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

输入格式：

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

输出格式

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

数据范围

1 ≤ n ≤ 7

输入样例

输出样例

代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 10;
int n;
int path[N];
bool state[N];

void dfs(int idx){
    if(idx > n) {
        for(int i = 1; i <= n; i ++){
            printf("%d ", path[i]);
        }
        cout << endl;
        return;
    }
    for(int i = 1; i <= n; i ++){
        if(!state[i]){
            state[i] = true;
            path[idx] = i;
            dfs(idx + 1);
            state[i] = false;
        }
    }
}

int main(){
    scanf("%d", &n);
    dfs(1);
    return 0;
}

思路

DFS问题需注意以下几点：

递归参数、终止条件以及回溯过程

①递归参数

idx为当前已经参与排列的数的个数

②终止条件

当n个数全部排列完成后，达到终止条件

③回溯过程

需要用一个状态数组记录某个数字是否被已经参与排列，回溯状态即更新该数字为未选中状态

细节部分：

需要输出每种排列情况，即当递归到最后一个数字时输出，所以采用path数组记录每个排列的结果

2. N皇后问题

问题描述

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

输入格式：

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

输出格式

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

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

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

注意：行末不能有多余空格。

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

数据范围

1 ≤ n ≤ 9

输入样例

输出样例

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

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

代码

法1：递归遍历每个格子

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 20;
char g[N][N];
//col记录每一列的状态, a[N]记录正对角线的状态, b[N]记录反对角线的状态
bool row[N], col[N], a[N], b[N];
int n;

// (x,y)表示当前枚举的坐标, sum表示当前一共填放了多少个皇后
void dfs(int x, int y, int sum){
    if(y == n) {      //枚举完一行
        y = 0;
        x ++;
    }
    // 枚举完所有行
    if(x == n){
        if(sum == n){   //若当前已填满所有皇后, 则输出结果
            for(int i = 0; i < n; i ++){
                cout << g[i];
                cout << endl;
            }
            cout << endl;
        }
            return;
    }
    //该位置不放皇后
    dfs(x, y + 1, sum);
    //该位置放皇后
    if(!row[x] && !col[y] && !a[x + y] && !b[x - y + n]){
        g[x][y] = 'Q';
        row[x] = true, col[y] = true, a[x + y] = true, b[x - y + n] = true;
        dfs(x, y + 1, sum + 1);
        row[x] = false, col[y] = false, a[x + y] = false, b[x - y + n] = false;
        g[x][y] = '.';
    }
}

int main(){
    scanf("%d", &n);
    for(int i = 0; i < n; i ++){
        for(int j = 0; j < n; j ++){
            g[i][j] = '.';
        }
    }
    dfs(0, 0, 0);
    return 0;
}

法2：递归遍历每一行

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 20;
char g[N][N];
//col记录每一列的状态, a[N]记录正对角线的状态, b[N]记录反对角线的状态
bool col[N], a[N], b[N];
int n;

// u表示当前遍历的行
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;
        return;
    }
    for(int i = 0; i < n; i ++){
        if(!col[i] && !a[u + i] && !b[i - u + n]){
            g[u][i] = 'Q';
            col[i] = true, a[u + i] = true, b[i - u + n] = true;
            dfs(u + 1);
            col[i] = false, a[u + i] = false, b[i - u + n] = false;
            g[u][i] = '.';
        }
    }
}

int main(){
    scanf("%d", &n);
    for(int i = 0; i < n; i ++){
        for(int j = 0; j < n; j ++){
            g[i][j] = '.';
        }
    }
    dfs(0);
    return 0;
}