所有可能的路径（Leetcode-797）-回溯法 & 记忆化搜索

题目

• 原题连接：https://leetcode-cn.com/problems/all-paths-from-source-to-target/
  

知识点

• 方法1：回溯法
• 方法2：记忆化搜索

思路

回溯法

• 首先对于题目是明确说明没有有向无环图的，因此我们不需要设置数组去记录经过的节点去避免进入环的情况，因此我们只需要递归访问当前节点访问它能到达的节点，直到终点结束，记录下结果。

动态规划

• 对于很多情况下的路只要走过一遍，那么我们可以路径记录下来，以[[3,1],[4,6,7,2,5],[4,6,3],[6,4],[7,6,5],[6],[7],[]]为例（其中的1个样例），结果如下：

  [[0,3,6,7],[0,3,4,7],[0,3,4,6,7],[0,3,4,5,6,7],[0,1,4,7],[0,1,4,6,7],[0,1,4,5,6,7],[0,1,6,7],[0,1,7],[0,1,2,4,7],[0,1,2,4,6,7],[0,1,2,4,5,6,7],[0,1,2,6,7],[0,1,2,3,6,7],[0,1,2,3,4,7],[0,1,2,3,4,6,7],[0,1,2,3,4,5,6,7],[0,1,5,6,7]]

  我们可以看到，其中[0,3,4,7],[0,3,4,6,7],[0,3,4,5,6,7]都访问到了4以后的节点，并得到的了所有从4出发到终点的所有路径，即[4,7]、[4,6,7]、[4,5,6,7]。而从1节点开始也可以走到4,[0,1,4,7],[0,1,4,6,7],[0,1,4,5,6,7]，这时候我们不需要从4开始再去递归访问过的结果，直接返回以4开始所有到终点的路径即可。

• 总体思路如下，对于当前节点i，for循环找到下一个节点j，用vector<vector<int>> all_routes记录该点出发所有能到达的路径并用于最后返回，用map<int, vector<vector<int>>> vis记忆化所有从int开始能到达终点的路径：

  • 如果该节点已经从其他路径访问过，直接返回从该节点出发到终点的路径， 然后加上当前节点i，得到从i出发到j后所有能到达的路径，并保存到vis[i]中（记忆化）（Line 14-21）。

    比如上面例子在访问4开始到达的所有节点以后vis[4]中就记录了[4,7]、[4,6,7]、[4,5,6,7]，直接加上i后（[i,4,7]、[i,4,6,7]、[i,4,5,6,7]），保存在vis[i]中，下次访问到i直接就可以返回结果（PS：i相邻节点j到达的都要保存，并不是只有上面的4，如果相邻还有5，我们还要把5能到达的都放入vis[i]中）

  • 如果该节点没有从其他路径访问过，那我们直接dfs(graph, next)得到以next为下一个节点所能到达终点的所有路径。并加上当前节点i，保存在vis[i]中（Line 24-30） 。

代码

回溯法代码

class Solution {
public:
    vector <vector <int>> res;
    int ed;

    void dfs(vector<vector<int>>& graph, int node, vector <int> path){
        if (node == ed){
            res.emplace_back(path);
            return;
        }

        for (int next:graph[node]){
            path.emplace_back(next);
            dfs(graph, next, path);
            path.pop_back();
        }
    }

    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        ed = graph.size() - 1;
        dfs(graph, 0, vector<int>({0}));
        return res;
    }
};

记忆化搜索完整代码

• 似乎是vector操作的问题，效率并没有想象中那么快

class Solution {
public:
    map<int, vector<vector<int>>> vis;
    int ed;

    vector<vector<int>> dfs(vector<vector<int>> &graph, int node) {
        if (node == ed) {
            return vector<vector<int>>({{node}});
        }

        vector<vector<int>> all_routes;
        for (int next:graph[node]) {
            // 之前访问过，直接把所有可能的路径+当前节点即可
            if (vis.count(next)) {
                for (vector<int> u:vis[next]) {
                    u.insert(u.begin(), node);
                    vis[node].emplace_back(u);
                    all_routes.emplace_back(u);
                }
                continue;
            }
            // 第一次访问，递归访问得到后面的所有结果，再加上当前节点
            vector<vector<int>> ans = dfs(graph, next);
            if (!ans.empty()) {
                for (vector<int> u:ans){
                    u.insert(u.begin(),node);
                    vis[node].emplace_back(u);
                    all_routes.emplace_back(u);
                }
            }
        }
        return all_routes;
    }

    vector<vector<int>> allPathsSourceTarget(vector<vector<int>> &graph) {
        ed = graph.size() - 1;
        return dfs(graph, 0);
    }
};