LeetCode 797. All Paths From Source to Target

题目链接：https://leetcode.com/problems/all-paths-from-source-to-target/description/

Given a directed, acyclic graph of N nodes.  Find all possible paths from node 0 to node N-1, and return them in any order.

The graph is given as follows:  the nodes are 0, 1, ..., graph.length - 1.  graph[i] is a list of all nodes j for which the edge (i, j) exists.

Example:
Input: [[1,2], [3], [3], []] 
Output: [[0,1,3],[0,2,3]] 
Explanation: The graph looks like this:
0--->1
|    |
v    v
2--->3
There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.

Note:

• The number of nodes in the graph will be in the range [2, 15].
• You can print different paths in any order, but you should keep the order of nodes inside one path.

题目解析：dfs一下，加一个访问标记。

代码如下：56ms Accepted beating 89.22%

class Solution {
public:
    int vis[20] = {0};
    void dfs(vector<vector<int>>& graph, vector<vector<int>>& results, vector<int> result, int current, int target){
        if (current == target)
        {
            results.push_back(result);
            return;
        }
        for (auto next : graph[current])
        {
            if (vis[next])
                continue;
            vis[next] = 1;
            result.push_back(next);
            dfs(graph, results, result, next, target);
            result.pop_back();
            vis[next] = 0;
        }
    }
    
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        vector<vector<int>> results;
        vector<int> result = {0};
        vis[0] = 1;
        dfs(graph, results, result, 0, graph.size() - 1);
        return results;
    }
};

提交之后看到最快运行速度是52ms，看了下代码没怎么明白具体原因，欢迎大佬评论解释一下，参考代码贴在下面——

class GraphVertex
{
    public:
    
        GraphVertex(vector<int> friends):neighbors(friends),visit(false){}
        vector<int> neighbors;
        bool visit;
};


class Solution {
public:
    
    void dfsHelper(vector<GraphVertex>& graph,int start,int end,vector<int>& path,vector<vector<int> >& path_set)
    {
        if ( start == end)
        {
            path_set.push_back(path);
            return;
        }
        
        vector<int> neighbors=graph[start].neighbors;
        for ( int i =0; i < neighbors.size(); ++i)
        {
            if ( !graph[neighbors[i]].visit)
            {
                graph[neighbors[i]].visit=true;
                path.push_back(neighbors[i]);
                dfsHelper(graph,neighbors[i],end,path,path_set);
                path.pop_back();
                graph[neighbors[i]].visit=false;
                
            }
        }
      
    }
    
    
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        
        vector<GraphVertex> adjancency_list;
        for ( int i=0; i < graph.size() ; ++i)
        {
            adjancency_list.push_back(GraphVertex(graph[i]));
        }
        
        vector<vector<int> > set_of_paths;
        vector<int> path;
        
        path.push_back(0);
        adjancency_list[0].visit=true;
        
        dfsHelper(adjancency_list,0,graph.size()-1,path,set_of_paths);
        
        
        return set_of_paths;
        
    }
};