1. 深度搜索（DFS）的本质与核心思想
深度优先搜索（Depth-First Search）是一种用于遍历或搜索树或图的算法。这个算法会尽可能深地搜索树的分支，直到无法继续为止，然后回溯到上一个节点继续搜索其他分支。
我第一次接触DFS是在解决迷宫问题时。当时尝试用递归方法走出迷宫，发现程序总是沿着一条路走到黑，碰壁后再回退寻找新路径——这正是DFS的核心特征。与广度优先搜索（BFS）不同，DFS更注重"深度"而非"广度"，这种特性使其在解决某些问题时特别高效。
DFS通常通过递归或显式栈来实现。递归实现最为直观，代码简洁但可能面临栈溢出风险；显式栈实现稍复杂但更可控。在C++中，我们常用vector或stack作为显式栈的数据结构。
关键理解：DFS的"深度优先"特性使其天然适合解决需要探索所有可能性的问题，如排列组合、连通性检测等。它的回溯特性也是解决许多难题的关键。
2. DFS的递归实现框架与关键技术点
2.1 基础递归模板
一个标准的DFS递归实现包含三个关键部分：
- 终止条件（何时停止递归）
- 当前层处理（如何处理当前节点）
- 递归调用（如何进入下一层）
cpp复制void dfs(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层节点处理) {
处理节点;
dfs(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
2.2 方向数组的使用技巧
在网格类问题中，方向数组是DFS的得力助手。以下是一个经典的4方向数组定义：
cpp复制const int dirX[4] = {0, 0, -1, 1}; // 左右移动
const int dirY[4] = {-1, 1, 0, 0}; // 上下移动
使用时配合边界检查，可以优雅地实现网格遍历：
cpp复制for (int i = 0; i < 4; i++) {
int newX = x + dirX[i];
int newY = y + dirY[i];
if (newX >= 0 && newX < rows && newY >= 0 && newY < cols) {
dfs(grid, newX, newY);
}
}
2.3 访问标记的多种实现方式
防止重复访问是DFS的关键，常见标记方法有：
- 修改原数据（如将访问过的格子设为0）
- 使用独立的visited数组
- 位图标记（适用于空间敏感场景）
- 哈希表存储（适用于非连续节点）
在图像渲染问题中，我们采用了第一种方法：
cpp复制if (image[sr][sc] == curColor) {
image[sr][sc] = color; // 修改原数据作为标记
// 继续DFS...
}
3. 典型DFS例题精解
3.1 图像渲染问题（Flood Fill）
LeetCode 733题是DFS的经典应用。问题描述：给定一个二维数组表示的图像，从指定像素开始，将所有颜色相同的连通区域染成新颜色。
cpp复制class Solution {
public:
vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
int oldColor = image[sr][sc];
if (oldColor != color) dfs(image, sr, sc, oldColor, color);
return image;
}
void dfs(vector<vector<int>>& image, int x, int y, int oldColor, int newColor) {
if (x < 0 || x >= image.size() || y < 0 || y >= image[0].size() ||
image[x][y] != oldColor) return;
image[x][y] = newColor;
dfs(image, x+1, y, oldColor, newColor);
dfs(image, x-1, y, oldColor, newColor);
dfs(image, x, y+1, oldColor, newColor);
dfs(image, x, y-1, oldColor, newColor);
}
};
实际调试中发现：当新旧颜色相同时必须直接返回，否则会导致无限递归。这是DFS实现中常见的边界条件陷阱。
3.2 岛屿最大面积问题
LeetCode 695题要求找到二维网格中最大的岛屿面积（连通1的个数）。DFS解法通过遍历每个单元格，遇到1时启动DFS统计面积。
cpp复制class Solution {
public:
int maxAreaOfIsland(vector<vector<int>>& grid) {
int maxArea = 0;
for (int i = 0; i < grid.size(); i++) {
for (int j = 0; j < grid[0].size(); j++) {
if (grid[i][j] == 1) {
int area = 0;
dfs(grid, i, j, area);
maxArea = max(maxArea, area);
}
}
}
return maxArea;
}
void dfs(vector<vector<int>>& grid, int x, int y, int& area) {
if (x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() ||
grid[x][y] != 1) return;
grid[x][y] = 0; // 标记为已访问
area++;
dfs(grid, x+1, y, area);
dfs(grid, x-1, y, area);
dfs(grid, x, y+1, area);
dfs(grid, x, y-1, area);
}
};
3.3 二叉树合并问题
LeetCode 617题要求合并两棵二叉树，对应节点值相加。DFS解法优雅地处理了各种节点存在情况：
cpp复制class Solution {
public:
TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
if (!t1) return t2;
if (!t2) return t1;
TreeNode* merged = new TreeNode(t1->val + t2->val);
merged->left = mergeTrees(t1->left, t2->left);
merged->right = mergeTrees(t1->right, t2->right);
return merged;
}
};
4. DFS的优化与性能分析
4.1 递归深度与栈溢出
DFS的递归实现可能面临栈溢出风险。对于深度可能很大的问题（如链状图），应考虑：
- 改用显式栈的迭代实现
- 设置递归深度限制
- 使用尾递归优化（某些编译器支持）
显式栈实现示例：
cpp复制void dfsIterative(vector<vector<int>>& grid, int x, int y) {
stack<pair<int, int>> s;
s.push({x, y});
grid[x][y] = 0;
while (!s.empty()) {
auto [cx, cy] = s.top();
s.pop();
for (int i = 0; i < 4; i++) {
int nx = cx + dirX[i];
int ny = cy + dirY[i];
if (nx >= 0 && nx < grid.size() && ny >= 0 && ny < grid[0].size() &&
grid[nx][ny] == 1) {
grid[nx][ny] = 0;
s.push({nx, ny});
}
}
}
}
4.2 剪枝优化策略
在搜索空间大的问题中，剪枝能显著提升性能：
- 可行性剪枝：提前终止不可能产生解的分支
- 最优性剪枝：当当前路径已不可能优于已知最优解时终止
- 记忆化：存储已计算子问题的结果
以排列问题为例，通过标记已使用元素避免重复选择：
cpp复制void dfs(vector<int>& nums, vector<bool>& used, vector<int>& path, vector<vector<int>>& res) {
if (path.size() == nums.size()) {
res.push_back(path);
return;
}
for (int i = 0; i < nums.size(); i++) {
if (used[i]) continue; // 剪枝：跳过已使用元素
used[i] = true;
path.push_back(nums[i]);
dfs(nums, used, path, res);
path.pop_back();
used[i] = false;
}
}
4.3 时间复杂度分析
DFS的时间复杂度取决于：
- 图的问题：O(V+E)，V为顶点数，E为边数
- 网格问题：O(M×N)，M行N列
- 组合问题：O(N!)，如全排列
空间复杂度主要来自：
- 递归调用栈：最坏O(N)
- 显式栈：O(N)
- 访问标记：O(N)或O(M×N)
5. DFS的变种与应用扩展
5.1 回溯算法
回溯是DFS的重要应用，通过"试错"思想解决问题。典型问题包括：
- 八皇后问题
- 数独求解
- 组合总和
回溯模板：
cpp复制void backtrack(路径，选择列表) {
if (满足结束条件) {
存放结果;
return;
}
for (选择 in 选择列表) {
做选择;
backtrack(路径，选择列表);
撤销选择;
}
}
5.2 记忆化DFS
在存在重复子问题的情况下，通过存储中间结果提升效率。以斐波那契数列为例：
cpp复制int fib(int n, vector<int>& memo) {
if (n <= 1) return n;
if (memo[n] != -1) return memo[n];
memo[n] = fib(n-1, memo) + fib(n-2, memo);
return memo[n];
}
5.3 迭代加深DFS
结合DFS和BFS优点的算法，适用于：
- 搜索空间大但解可能在浅层
- 需要最优解但内存有限
实现框架：
cpp复制for (int depth = 0; depth < MAX_DEPTH; depth++) {
if (dfsLimited(root, depth)) break;
}
6. DFS实战经验与调试技巧
6.1 常见错误排查
- 无限递归：通常由于缺少终止条件或条件错误
- 错误结果：检查回溯逻辑是否正确恢复状态
- 栈溢出：考虑改用迭代实现或增大栈空间
- 访问越界：网格问题中务必检查边界
6.2 调试输出技巧
在DFS中添加调试输出可以帮助理解递归流程：
cpp复制void dfs(参数) {
cout << "进入节点：" << 当前节点 << endl;
// ...处理逻辑...
for (auto& next : 相邻节点) {
dfs(next);
}
cout << "离开节点：" << 当前节点 << endl;
}
6.3 性能优化实践
- 将递归改为迭代
- 使用更高效的数据结构（如用数组代替vector）
- 减少不必要的状态拷贝
- 提前剪枝
在竞赛编程中，我习惯预先分配好所有需要的数据结构，避免在DFS中频繁分配释放内存。例如：
cpp复制vector<vector<bool>> visited(rows, vector<bool>(cols, false));
// 而不是在DFS中动态创建
7. 进阶例题与综合应用
7.1 单词搜索问题
LeetCode 79题要求在二维网格中查找是否存在某个单词。DFS需要处理路径回溯和多个起始点：
cpp复制class Solution {
public:
bool exist(vector<vector<char>>& board, string word) {
for (int i = 0; i < board.size(); i++) {
for (int j = 0; j < board[0].size(); j++) {
if (dfs(board, word, i, j, 0)) return true;
}
}
return false;
}
bool dfs(vector<vector<char>>& board, string& word, int x, int y, int index) {
if (index == word.size()) return true;
if (x < 0 || x >= board.size() || y < 0 || y >= board[0].size() ||
board[x][y] != word[index]) return false;
char temp = board[x][y];
board[x][y] = '#'; // 标记为已访问
bool found = dfs(board, word, x+1, y, index+1) ||
dfs(board, word, x-1, y, index+1) ||
dfs(board, word, x, y+1, index+1) ||
dfs(board, word, x, y-1, index+1);
board[x][y] = temp; // 恢复原始值
return found;
}
};
7.2 括号生成问题
LeetCode 22题要求生成所有有效的括号组合。DFS需要跟踪开闭括号数量：
cpp复制class Solution {
public:
vector<string> generateParenthesis(int n) {
vector<string> res;
dfs(res, "", 0, 0, n);
return res;
}
void dfs(vector<string>& res, string current, int open, int close, int max) {
if (current.length() == max * 2) {
res.push_back(current);
return;
}
if (open < max) dfs(res, current + "(", open + 1, close, max);
if (close < open) dfs(res, current + ")", open, close + 1, max);
}
};
7.3 课程安排问题
LeetCode 207题检测课程安排是否无环。DFS用于检测环：
cpp复制class Solution {
public:
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
vector<vector<int>> graph(numCourses);
for (auto& p : prerequisites) {
graph[p[1]].push_back(p[0]);
}
vector<int> visited(numCourses, 0); // 0未访问，1访问中，2已访问
for (int i = 0; i < numCourses; i++) {
if (hasCycle(graph, visited, i)) return false;
}
return true;
}
bool hasCycle(vector<vector<int>>& graph, vector<int>& visited, int course) {
if (visited[course] == 1) return true;
if (visited[course] == 2) return false;
visited[course] = 1;
for (int neighbor : graph[course]) {
if (hasCycle(graph, visited, neighbor)) return true;
}
visited[course] = 2;
return false;
}
};
8. DFS与其他算法的比较与选择
8.1 DFS vs BFS
| 特性 | DFS | BFS |
|---|---|---|
| 数据结构 | 栈（递归/显式） | 队列 |
| 空间复杂度 | O(树高) | O(最宽层节点数) |
| 适用场景 | 寻找所有解、连通性 | 最短路径、层次遍历 |
| 实现复杂度 | 递归实现简单 | 需显式维护队列 |
8.2 何时选择DFS
- 需要遍历所有可能解（如排列组合）
- 问题具有递归性质（如树、图的遍历）
- 内存受限且解可能在深层
- 需要利用回溯特性（如迷宫问题）
8.3 混合使用DFS和BFS
某些问题需要结合两种算法优势：
- 迭代加深DFS：结合DFS的空间效率和BFS的完备性
- 双向搜索：从起点和终点同时进行DFS/BFS
- 启发式搜索：如A*算法结合DFS和优先队列
9. C++实现DFS的工程实践
9.1 代码组织建议
对于复杂DFS问题，建议：
- 将核心DFS逻辑独立为函数
- 使用类封装相关数据和辅助函数
- 分离问题输入处理和结果输出
例如：
cpp复制class MazeSolver {
private:
vector<vector<int>> maze;
vector<vector<bool>> visited;
vector<pair<int, int>> path;
bool dfs(int x, int y) {
// DFS实现...
}
public:
MazeSolver(vector<vector<int>> m) : maze(m) {
visited.resize(maze.size(), vector<bool>(maze[0].size(), false));
}
vector<pair<int, int>> findPath() {
if (dfs(0, 0)) return path;
return {};
}
};
9.2 性能敏感场景的优化
- 使用静态数组代替vector
- 用位运算压缩状态
- 减少函数调用开销（如将辅助函数内联）
- 预分配所有需要的内存
9.3 多线程DFS实现
对于可分解的搜索问题，可以考虑并行化：
cpp复制void parallelDFS(参数) {
vector<thread> threads;
// 分解问题到多个线程
for (int i = 0; i < threadCount; i++) {
threads.emplace_back([=] {
dfs(子问题参数);
});
}
for (auto& t : threads) t.join();
}
10. 从DFS到更高级的搜索技术
10.1 启发式搜索
在DFS基础上引入评估函数：
- 最佳优先搜索
- A*算法
- IDA*算法
10.2 约束满足问题
DFS是解决约束满足问题（CSP）的基础：
- 数独求解
- 地图着色
- 排课系统
10.3 人工智能中的应用
- 博弈树搜索（如围棋、象棋AI）
- 状态空间搜索（如自动规划）
- 组合优化问题求解
在开发五子棋AI时，我使用带alpha-beta剪枝的DFS搜索可能的走法，配合评估函数选择最优策略。这种组合在实践中效果显著：
cpp复制int alphaBetaSearch(Board& board, int depth, int alpha, int beta, bool maximizing) {
if (depth == 0 || board.isGameOver()) {
return board.evaluate();
}
if (maximizing) {
int value = INT_MIN;
for (auto& move : board.getPossibleMoves()) {
board.makeMove(move);
value = max(value, alphaBetaSearch(board, depth-1, alpha, beta, false));
board.undoMove(move);
alpha = max(alpha, value);
if (alpha >= beta) break;
}
return value;
} else {
// 类似的最小化过程...
}
}