理解递归与深度优先搜索（DFS）

Maker-

于 2024-10-06 15:42:44 发布

阅读量258

点赞数 15

文章标签：深度优先算法 c++

本文链接：https://blog.csdn.net/weixin_68174634/article/details/142727614

版权

前言

递归和深度优先搜索（DFS）在编程中经常出现在一起。递归是一种将复杂问题逐步简化、分解的方式，而 DFS 则是递归的一种典型应用。通过理解它们的关系，不仅能帮助我们轻松解决许多复杂问题，还能提高我们的算法设计能力。

递归的核心：信任程序

递归的关键思想可以归纳为：“信任程序能一步步解决问题”。通过递归，我们将大问题分解为相似的子问题，程序会逐步深入解决每个子问题，并在适当的时候回溯，最终完成整个任务。

递归函数通常包括两个部分：
1. 终止条件：当问题简化到一个基本情况时，递归停止。
2. 递归调用：函数调用自身来处理问题的子部分。

示例：阶乘

阶乘的递归定义是一个经典的例子。它定义了一个数 n 的阶乘为 n! = n * (n-1) * (n-2) * ... * 1，当 n == 0 时，n! = 1。

int factorial(int n) {
    if (n == 0) {  // 终止条件
        return 1;
    } else {
        return n * factorial(n - 1);  // 递归调用
    }
}

在这个例子中，递归的核心思想是"逐步简化问题"。我们只需信任递归函数能完成其余部分的工作。每次递归调用都处理一个更小的子问题，直到 n == 0 时停止。

示例：斐波那契数列

另一个经典的递归问题是计算斐波那契数列。斐波那契数列的递归定义为：
F(0) = 0, F(1) =1
F(n) = F(n-1) + F(n-2) 对于 n >= 2。

我们同样可以通过递归轻松实现这一算法：

int fibonacci(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    return fibonacci(n - 1) + fibonacci(n - 2);  // 递归调用
}

通过这个例子，我们可以看到递归的一个典型特性：每次递归调用都在解决一个更小的问题。当 n足够小（即 n == 0 或 n == 1）时，递归停止。

深度优先搜索（DFS）：递归的典型应用

深度优先搜索（DFS）是一种图或树的遍历算法。它的思想非常简单：从一个节点开始，沿着一个路径不断向下深入，直到无法继续为止，然后回溯并探索其他路径。这与递归的过程非常相似，每次递归调用都对应于一次深度的探索。

示例：迷宫问题中的 DFS

让我们通过一个迷宫问题来演示如何使用递归实现 DFS。假设我们有一个二维的迷宫矩阵，起点在左上角 (0, 0)，终点在右下角 (n-1, m-1)，我们需要找到一条通往终点的路径。


bool isValid(int x, int y,
 vector<vector<int>>& maze,
 vector<vector<bool>>& visited) 
{
    return (x >= 0 && x < maze.size() && y >= 0 
&& y < maze[0].size() 
&& maze[x][y] == 0 && !visited[x][y]);
}

bool dfs(int x, int y, vector<vector<int>>&
 maze, vector<vector<bool>>& visited) 
{
    if (x == maze.size() - 1 
&& y == maze[0].size() - 1) return true;  // 到达终点
    
    visited[x][y] = true;  // 标记当前节点已访问
    
    // 尝试向四个方向移动
    int dx[] = {0, 1, 0, -1};
    int dy[] = {1, 0, -1, 0};
    
    for (int i = 0; i < 4; ++i) {
        int newX = x + dx[i], newY = y + dy[i];
        if (isValid(newX, newY, maze, visited) 
&& dfs(newX, newY, maze, visited)) 
{
            return true;
        }
    }
    
    visited[x][y] = false;  // 回溯
    return false;
}

在这个迷宫例子中，DFS 的思想非常直观。我们从起点 (0, 0)`出发，探索每一个可能的路径，递归地尝试所有的可能方向。每次成功到达终点时，递归返回 true，而如果当前路径走不通，则回溯并尝试其他方向。

递归与 DFS 的共同点

通过前面的例子我们可以看到，递归和 DFS 的本质是一样的，它们都通过逐步深入的方式解决问题，并在必要时回溯以探索新的分支。它们的主要共同点包括：
1. 逐步深入：无论是递归还是 DFS，算法都会一步步深入到更深的层次，直到遇到终止条件。
2. 回溯机制：当无法继续时，递归或 DFS 都会回到上一步，寻找其他解决方案。这就是回溯的本质。
3. 栈结构：递归调用利用系统的函数调用栈来存储中间状态，而 DFS 通常也通过显式或隐式的栈结构进行状态管理。