DFS实现迷宫和数独

最新推荐文章于 2024-04-07 10:22:37 发布

mathematicians

最新推荐文章于 2024-04-07 10:22:37 发布

阅读量731

点赞数 15

文章标签：深度优先算法

本文链接：https://blog.csdn.net/mathematicians/article/details/136312670

版权

本文详细介绍了深度优先搜索（DFS）算法，包括其定义、工作原理、举例说明（如迷宫和数独问题），以及其特点如连通分量和拓扑排序的应用。通过递归模型展示了DFS的执行过程。

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

DFS定义：

深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。

例子：

举例说明之：下图是一个无向图，如果我们从A点发起深度优先搜索（以下的访问次序并不是唯一的，第二个点既可以是B也可以是C,D），则我们可能得到如下的一个访问过程：A->B->E（没有路了，回溯到A)->C->F->H->G->D（没有路，最终回溯到A,A也没有未访问的相邻节点，本次搜索结束）。

简要说明深度优先搜索的特点：每次深度优先搜索的结果必然是图的一个连通分量。深度优先搜索可以从多点发起。如果将每个节点在深度优先搜索过程中的"结束时间"排序（具体做法是创建一个list，然后在每个节点的相邻节点都已被访问的情况下，将该节点加入list结尾，然后逆转整个链表)，则我们可以得到所谓的"拓扑排序"，即topological sort。

————摘编自百度百科

DFS算法模型

DFS是函数递归调用自身的一种算法。一般而言，它的模型如下：

dfs(某个节点){
    if(该节点为结束或无法继续深搜下去){
        跳出递归
        return;
    }
    else{
        标记该节点为已用;
        dfs(所有该节点相邻的未用节点）;
        回溯（这步很重要）
        标记该节点为未用;
    }
}

就拿上面这张图来举例：

在这张图中我们希望走出这个图，而不是在图中不断循环（就是不能ACFHGDA...）

我们先dfs(A)，把A标记为已用，与A相邻且为标记已用的点为BCD，我们先dfs(D)（一般BCD顺序不是很重要）。与D相邻且未被标记已用的节点为G（A已用了），于是我们再dfs(G)，然后是HFC，注意到，此时与C相邻的节点都被标记已用了，所以C这条路就是不通的。接下来我们要回溯。首先取消C点的标记，然后回溯回C的上一个节点F，但F也不行，于是继续回溯，一直回溯到A，我们发现A还有其他节点为走过，于是dfs(C)，接下来同理即可。

DFS举例一：迷宫

给定一个N*M的迷宫，起点和终点分别用S和T来表示，*表示墙，. 表示路，你只需要显示出一条可以走出迷宫的路线即可。

#include<iostream>
#include<string>
using namespace std;
int N, M;
const int MAXSIZE = 100;
string maze[MAXSIZE];
bool IsVisit[MAXSIZE][MAXSIZE];
int dir[4][2] = { {-1,0},{0,-1},{1,0},{0,1} };
bool IsIn(int x, int y) {
	return x >= 0 && x < N && y >= 0 && y < M;
}
bool dfs(int x, int y){
	if (maze[x][y] == 'T') return true;
	IsVisit[x][y] = 1;
	maze[x][y] = 'm';
	for (int i = 0; i < 4; i++){
		int a = x + dir[i][0];
		int b = y + dir[i][1];
		if (IsIn(a, b) && maze[a][b] != '*' && !IsVisit[a][b] && (dfs(a, b))) return true;
	}
	IsVisit[x][y] = 0;
	maze[x][y] = '.';
	return false;
}
int main(){
	cin >> N >> M;
	for (int i = 0; i < N; i++) cin >> maze[i];
	int X = -1, Y = -1;
	for (int i = 0; i < N; i++){
		for (int j = 0; j < M; j++){
			if (maze[i][j] == 'S'){
				X = i;
				Y = j;
			}
		}
	}
	if (X == -1 && Y == -1) {
		cout << "NO!" << endl;
		return 0;
	}
	if (dfs(X,Y)){
		for(int i=0;i<N;i++) cout << maze[i] << endl;
	}
	else cout << "NO!" << endl;
	return 0;
}

DFS举例二：数独

给定一个9*9的网格，每个网格填入数字1~9，要求每行，每列，每个九宫格里面只能填一个数。

#include<iostream>
#include<cstring>

using namespace std;

const int N = 9, M = 1 << N;
char str[100];
bool col[N][10], row[N][10], squ[3][3][10];
bool dfs(int x, int y){
    if (x == N && y == 0) return true;
    if (str[x * N + y] != '.'){
        if (y == N - 1){
            if (dfs(x + 1, 0)) return true;
            return false;
        }
        else{
            if (dfs(x, y + 1)) return true;
            return false;
        }
    }
    for (int i = 1; i <= 9; i++)
        if (!row[x][i] && !col[y][i] && !squ[x / 3][y / 3][i]){
            str[x * N + y] = i + '0';
            row[x][i] = true;
            col[y][i] = true;
            squ[x / 3][y / 3][i] = true;
            if (y == N - 1){
                if (dfs(x + 1, 0)) return true;
            }
            else{
                if (dfs(x, y + 1)) return true;
            }
            str[x * N + y] = '.';
            row[x][i] = false;
            col[y][i] = false;
            squ[x / 3][y / 3][i] = false;

        }
    return false;
}
void init(){
    memset(row, false, sizeof row);
    memset(col, false, sizeof col);
    memset(squ, false, sizeof squ);
}
int main(){
    while (cin >> str, str[0] != 'e'){
        init();
        for (int i = 0, k = 0; i < N; i++)
            for (int j = 0; j < N; j++, k++)
                if (str[k] != '.'){
                    int t = str[k] - '0';
                    row[i][t] = true;
                    col[j][t] = true;
                    squ[i / 3][j / 3][t] = true;
                }
        dfs(0, 0);
        cout << str << endl;
    }
    return 0;
}