当前位置：首页 > news >正文

ch07课堂参考代码

news 来源：原创 2025/6/19 1:46:06

DFS 的优化

1) 标记搜索过的状态

用数组标记一个状态是否被搜索过，搜索过则直接 return，不用再执行函数，用于保证每个状态只被搜索一次。
在递归调用函数之前，通过 if (vis[x]) 判断 x 是否被搜索过，搜索过则直接return结束函数

在 if (vis[x]) 的判断之后 ，将 vis[x] 赋值为 true，表示当前搜索到 x 了，之后不用再重复搜索

bool dfs(int x) {
    if (x == m) return 1;
	// 优化，加上这两句：
    if (vis[x]) return 0; // 如果x能到达m，那么函数只有return没有递进搜索了，所以能第2次遇到x，说明x不能到达m，return false;
    vis[x] = 1;
    
    if (x % 2 == 0) { // 偶数
        if (dfs(x / 2)) return 1;
    } else { // 奇数
        if (dfs(x - 1)) return 1; // 成功到达立即返回，不走 x+1
        if (dfs(x + 1)) return 1;
    }
    return 0;
}

需要标记优化的情况：可能会重复搜索同一个状态，并且状态的表示要比较简单（用少数几个变量就能表示一个状态）。
状态用一个变量表示，就用一维数组标记，状态用两个变量表示，就用二维数组标记，以此类推。

2）判断是否有解+最优化问题！！！

最优化问题的题目特征是：从初始状态达到目标状态的最…值
当前状态对应的结果记录在数组中，也作为函数返回值返回
vis：状态是否访问
f：vis[x] == 1 的前提下，f[x] 表示到目标状态的答案：
f[x] == inf （也可根据题意设置 f[x] == -inf 等表示不可行）表示状态 x 无法到达目标状态
f[x] != inf：表示 x 能到达目标状态，且到目标状态的最优解（最小步数）为 f[x]

bool vis[maxn]; // 是否已访问该状态
int f[maxn]; // f[x]: x 到目标状态 m 的最小步数, f[x] == inf 表示无解

int m;
// 目标状态 m， x 是有可能 不能到达 m 的！！！
int dfs(int x) {
    if (vis[x]) return f[x];  // f[x] 是可能 == inf 的，表示无解
    vis[x] = 1, f[x] = inf; // 将无解设置为 inf，后续取 min 会自动舍弃无解;
    if (x == m) return f[x] = 0; // 目标状态
    // 枚举后继状态，在所有后继状态中打擂台求最小步数 
    if (x % 2 == 0) {
        f[x] = min(f[x], dfs(x / 2) + 1);
    } else {
        f[x] = min(f[x], dfs(x - 1) + 1);
        f[x] = min(f[x], dfs(x + 1) + 1);
    }
    return f[x];
}

DFS 解决“迷宫”类路径问题

前置知识：用数组表示往不同方向走的偏移量

const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1}; // 往上下左右四个方向走的偏移量
// 从第x行第y列往第i个方向走一步的新位置是第x+dx[i]行第y+dy[i]列
// 简单记为从(x,y)到(x+dx[i], y+dy[i])

在路径问题中，状态就是当前正在走的路径，需要用数组来表示这个状态。很多时候，不需要知道当前路径的每个位置，只关注路径的末尾位置，那么也可以不用数组记录路径，只用函数参数表示当前路径的末尾位置。
有时候需要快速判断某个位置是不是在当前路径中，可以用 bool 数组标记，inPath[x][y] = true 表示第 x 行第 y 列这个位置在当前状态（路径）中。
- 这与前面所说的“记忆化搜索”无关，对路径的 dfs 是不会重复搜索到相同的状态（路径）的，不需要记忆化搜索。inPath[x][y] 是为了标记 (x, y) 这个位置在不在当前状态（路径）中，而不是为了标记搜索过某个状态（路径）。

代码：

const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
const int N = 1010;
char ch[N][N]; // 输入的迷宫
int n, m; // 迷宫的行数和列数
struct P{
	int x, y;
} path[N*N]; // 记录状态（路径）的数组
bool inPath[N][N]; // inPath[x][y]标记(x,y)这个位置在不在当前路径中

// (x,y)是当前状态（路径）的末尾位置，len是当前路径的长度
void dfs(int x, int y, int len) {
	if (到达目标) {
		//......
		return ;
	}
    // 遍历上下左右四个位置
	for (int i = 0; i < 4; i++) {
        // 从末尾位置往第i个方向走一步的新位置(cx, cy)
		int cx = x + dx[i], cy = y + dy[i];
		if (新位置不合法) continue;
        // 不合法的判断一般有：1.越过了迷宫边界 2.该位置是障碍 3.该位置已经在路径中
		path[len+1] = {cx, cy}; // 新位置放入路径中
		inPath[cx][cy] = true;
		dfs(cx, cy, len + 1);
		inPath[cx][cy] = false; // 下次循环要换个位置，那么这个位置就不在路径中了
	}
}

int main() {
	//......
	path[1] = 起点; // 初始状态是只有起点的路径
	inPath[起点的x][起点的y] = true;
	dfs(起点的x, 起点的y, 1);
	
	return 0;
}