深度优先搜索(DFS)算法详解与C++实现

1. 深度优先搜索（DFS）基础概念解析

深度优先搜索（Depth-First Search）是图论中最基础的算法之一，也是每个C++开发者必须掌握的算法工具。我第一次接触DFS是在解决迷宫问题时，当时就被它简洁而强大的遍历能力所震撼。

DFS的核心思想可以用"不撞南墙不回头"来形容——算法会沿着一条路径不断深入，直到无法继续前进时才回溯到上一个分叉点。这种特性使得DFS特别适合解决以下类型的问题：

• 路径查找（迷宫问题、图连通性）
• 排列组合（全排列、子集生成）
• 树形结构遍历（二叉树路径、决策树）
• 状态空间搜索（八皇后、数独）

在C++中实现DFS通常有三种方式：

1. 递归实现：最直观的写法，利用函数调用栈自动处理回溯
2. 显式栈实现：用stack容器模拟递归过程
3. 邻接表实现：针对图结构的特定优化

新手常见误区：认为DFS只能用于图结构。实际上，任何具有"选择-探索-回溯"特征的问题都可以考虑DFS解法。

2. DFS的C++实现框架

2.1 递归模板实现

下面是一个标准的DFS递归模板，我将其分为四个关键部分：

cpp复制void dfs(参数列表) {
    // 1. 终止条件判断
    if (满足结束条件) {
        记录或处理结果;
        return;
    }
    
    // 2. 当前层处理逻辑
    处理当前节点;
    
    // 3. 递归深入
    for (所有可能的选项) {
        if (选项有效) {
            做出选择;
            dfs(新参数);  // 递归调用
            撤销选择;    // 回溯关键步骤
        }
    }
}

这个模板可以解决80%的DFS问题。以经典的排列问题为例：

cpp复制void permute(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]) {
            used[i] = true;
            path.push_back(nums[i]);
            permute(nums, used, path, res);
            path.pop_back();
            used[i] = false;
        }
    }
}

2.2 显式栈实现

当递归深度可能很大时（比如超过1万层），我们需要使用显式栈来避免栈溢出：

cpp复制void dfs_stack(Node* root) {
    if (!root) return;
    
    stack<Node*> stk;
    stk.push(root);
    
    while (!stk.empty()) {
        Node* curr = stk.top();
        stk.pop();
        
        处理当前节点;
        
        // 注意压栈顺序会影响遍历顺序
        if (curr->right) stk.push(curr->right);
        if (curr->left) stk.push(curr->left);
    }
}

2.3 性能优化技巧

在实际编码比赛中，我总结了几个提升DFS效率的技巧：

1. 剪枝优化：在进入递归前提前判断是否可能得到有效解

cpp复制if (当前路径已经不可能满足条件) {
    return;  // 剪枝
}

2. 记忆化搜索：使用哈希表存储已计算的状态

cpp复制unordered_map<string, bool> memo;

if (memo.count(状态字符串)) {
    return memo[状态字符串];
}

3. 迭代加深：限制搜索深度逐步扩大范围

cpp复制for (int depth = 1; depth <= max_depth; ++depth) {
    if (dfs(起始状态, depth)) {
        return true;
    }
}

3. 典型问题实战解析

3.1 岛屿数量问题

这是LeetCode上经典的DFS应用题（题目编号200），要求计算二维网格中岛屿的数量。

cpp复制void dfs(vector<vector<char>>& grid, int i, int j) {
    if (i < 0 || i >= grid.size() || j < 0 || j >= grid[0].size() || grid[i][j] != '1') {
        return;
    }
    
    grid[i][j] = '0';  // 标记为已访问
    dfs(grid, i + 1, j);
    dfs(grid, i - 1, j);
    dfs(grid, i, j + 1);
    dfs(grid, i, j - 1);
}

int numIslands(vector<vector<char>>& grid) {
    int count = 0;
    for (int i = 0; i < grid.size(); ++i) {
        for (int j = 0; j < grid[0].size(); ++j) {
            if (grid[i][j] == '1') {
                dfs(grid, i, j);
                ++count;
            }
        }
    }
    return count;
}

关键点：直接在原数组上修改标记访问状态，节省了额外的空间开销。这种"就地修改"的技巧在很多DFS问题中都适用。

3.2 组合总和问题

LeetCode 39题要求找出所有使数字和为目标数的组合，允许重复使用同一数字。

cpp复制void backtrack(vector<int>& candidates, int target, int start, vector<int>& path, vector<vector<int>>& res) {
    if (target == 0) {
        res.push_back(path);
        return;
    }
    
    for (int i = start; i < candidates.size(); ++i) {
        if (candidates[i] > target) continue;  // 剪枝
        
        path.push_back(candidates[i]);
        backtrack(candidates, target - candidates[i], i, path, res);  // 注意start参数保持i不变
        path.pop_back();
    }
}

这个例子展示了DFS在组合问题中的典型应用，需要注意：

1. 如何通过start参数控制选择范围
2. 剪枝条件的合理设置
3. 回溯时状态的恢复

4. DFS的变种与应用进阶

4.1 双向DFS

当搜索空间特别大时，可以同时从起点和终点开始搜索，在中途相遇：

cpp复制void bidirectional_dfs() {
    queue<Node*> q1, q2;
    unordered_set<Node*> visited1, visited2;
    
    q1.push(start);
    q2.push(end);
    
    while (!q1.empty() && !q2.empty()) {
        if (扩展q1时发现节点在visited2中) return 找到路径;
        if (扩展q2时发现节点在visited1中) return 找到路径;
    }
}

4.2 带权图的DFS

对于带权图，DFS需要记录路径权重：

cpp复制void weighted_dfs(Node* node, int current_weight) {
    if (current_weight > max_weight) return;
    
    for (auto& [neighbor, weight] : node->edges) {
        weighted_dfs(neighbor, current_weight + weight);
    }
}

4.3 拓扑排序

DFS也是实现拓扑排序的经典方法：

cpp复制bool topological_sort(vector<vector<int>>& graph) {
    vector<int> visited(graph.size(), 0);
    vector<int> result;
    
    for (int i = 0; i < graph.size(); ++i) {
        if (!dfs(graph, i, visited, result)) {
            return false;  // 存在环
        }
    }
    reverse(result.begin(), result.end());
    return true;
}

bool dfs(vector<vector<int>>& graph, int node, vector<int>& visited, vector<int>& result) {
    if (visited[node] == 1) return false;
    if (visited[node] == 2) return true;
    
    visited[node] = 1;
    for (int neighbor : graph[node]) {
        if (!dfs(graph, neighbor, visited, result)) {
            return false;
        }
    }
    visited[node] = 2;
    result.push_back(node);
    return true;
}

5. 调试与性能分析技巧

5.1 常见错误排查

在教学中我发现新手常犯的几个错误：

1. 忘记回溯：没有在递归调用后恢复状态

cpp复制// 错误示例
path.push_back(val);
dfs(path);
// 缺少 path.pop_back()

2. 终止条件不全：漏掉某些边界情况

cpp复制// 应该检查所有可能的终止条件
if (index >= nums.size()) {
    // 处理结果
}

3. 重复访问：在图中忘记标记已访问节点

cpp复制// 必须在使用节点后立即标记
visited[i][j] = true;

5.2 性能分析工具

我习惯使用以下工具分析DFS性能：

1. 时间复杂度估算：

   • 对于树形DFS：O(branches^depth)
   • 对于排列组合：O(n!)

2. 空间复杂度分析：

   • 递归深度决定空间复杂度
   • 显式栈版本通常空间效率更高

3. 实际测量工具：

cpp复制#include <chrono>

auto start = chrono::high_resolution_clock::now();
// 调用DFS函数
auto end = chrono::high_resolution_clock::now();
auto duration = chrono::duration_cast<chrono::microseconds>(end - start);
cout << "耗时: " << duration.count() << "微秒" << endl;

6. 从DFS到其他算法的思维迁移

掌握DFS后，可以很容易地过渡到其他相关算法：

1. 回溯算法：DFS+剪枝
2. 动态规划：DFS+记忆化
3. 分治算法：DFS的变种
4. BFS：将栈改为队列

以动态规划为例，很多DP问题都可以先用DFS思路写出暴力解法，再添加记忆化：

cpp复制// 斐波那契数列的DFS解法
int fib(int n) {
    if (n <= 1) return n;
    return fib(n-1) + fib(n-2);
}

// 加入记忆化后变为DP
unordered_map<int, int> memo;
int fib_dp(int n) {
    if (n <= 1) return n;
    if (memo.count(n)) return memo[n];
    return memo[n] = fib_dp(n-1) + fib_dp(n-2);
}

这种从DFS出发，逐步优化的思维方式，是我在算法教学中发现最有效的学习路径。