图论：深度优先搜索（DFS）

代码框架：

void dfs(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本节点所连接的其他节点) {
        处理节点;
        dfs(图，选择的节点); // 递归
        回溯，撤销处理结果
    }
}

例题：所有可能的路径   力扣链接：. - 力扣（LeetCode）

给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）

graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。

提示：

• n == graph.length
• 2 <= n <= 15
• 0 <= graph[i][j] < n
• graph[i][j] != i（即不存在自环）
• graph[i] 中的所有元素 互不相同
• 保证输入为 有向无环图（DAG）

先解释一下DAG（有向无环图）：

像刚刚的示例1中我们用数组graph = [[1,2],[3],[3],[]]表示了一个图,应该怎么理解呢?

• 数组中第0个元素为[1,2],表示节点0指向节点1和节点2
• 数组中第1个元素和第2个元素为[3],则表示节点1和节点2都指向节点3
• 节点3是最后一个节点,元素为空数组[],注意不能用当前节点为[]来判断是否为最后一个节点

相当于，graph[x]就是每个节点指向的东西，graph[x][y]就是指向过程中经过（遍历）的那个节点

题解：

class Solution {
private:
    vector<vector<int>> result; // 收集符合条件的路径
    vector<int> path; // 0节点到终点的路径
    // x：目前遍历的节点
    // graph：存当前的图
    void dfs (vector<vector<int>>& graph, int x) {
        // 要求从节点 0 到节点 n-1 的路径并输出，所以是 graph.size() - 1
        if (x == graph.size() - 1) { // 找到符合条件的一条路径
            result.push_back(path);
            return;
        }
        for (int i = 0; i < graph[x].size(); i++) { // 遍历节点n链接的所有节点
            path.push_back(graph[x][i]); // 遍历到的节点加入到路径中来
            dfs(graph, graph[x][i]); // 进入下一层递归
            path.pop_back(); // 回溯，撤销本节点
        }
    }
public:
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        path.push_back(0); // 无论什么路径已经是从0节点出发
        dfs(graph, 0); // 开始遍历
        return result;
    }
};

----------------------------------------------------------------------------------------------

补充一下岛屿问题的dfs解法：

原题：. - 力扣（LeetCode）

class Solution {
public:
    int dx[4] = {0,1, 0, -1};
    int dy[4] = {1, 0, -1, 0};
    void dfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y){//x,y是坐标
        if(visited[x][y] == true || grid[x][y] == '0'){//访问过的节点或遇到海水
            return;
        }
        visited[x][y] = true;
        for(int i=0; i<4; i++){
            int nextx = x+dx[i];
            int nexty = y+dy[i];
            if(nextx<0 || nextx>=grid.size() || nexty<0 || nexty>=grid[0].size()){
                continue;
            }
            //visited[nextx][nexty] = true;
            dfs(grid, visited, nextx, nexty);
            //visited[nextx][nexty] = false;
            //注释掉的是错误写法！不需要回溯！在正文写了原因
        }
    }
    int numIslands(vector<vector<char>>& grid) {
        int line = grid.size();
        int column = grid[0].size();
        int result=0;
        vector<vector<bool>> visited(line,vector<bool>(column,false));
        for(int i=0; i<line; i++){
            for(int j=0; j<column; j++){
                if(!visited[i][j] && grid[i][j] == '1'){
                    result++;
                    dfs(grid, visited, i, j);//将与其相连接的陆地都标记上true
                }
            }
        }
        return result;

    }
};

可以看到一开始下意识回溯了，但是不需要回溯，因为深度优先搜索（DFS）的过程中，我们遍历了岛屿中的每个位置，并将其标记为已访问。当我们进入一个相邻的未访问位置时，我们递归调用DFS函数。当我们完成这个递归调用后，我们回到了当前位置，并继续遍历其他相邻的位置。

由于我们将已访问的位置标记为visited，在后续的DFS遍历中，我们可以通过检查visited数组来跳过已访问的位置，从而避免重复遍历。这样，我们不需要撤销或回溯之前的操作，因为我们在遍历过程中已经记录了已访问的位置。

在这个问题中，我们只关心岛屿的面积，而无需还原或撤销对已访问位置的标记。因此，我们可以在DFS遍历过程中直接更新岛屿面积，而不需要回溯的步骤。

参考：

代码随想录

算法:所有可能的路径简单解析&如何用数组表示图 - 知乎