題目：

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問題。
python程式碼：

class Solution(object):
    def allPathsSourceTarget(self, graph):
        """
        :type graph: List[List[int]]
        :rtype: List[List[int]]
        """
 

        result=[]
        def dfs(index,path):
        	#新增到result之後無需再遍歷index的連線了。
            if index==len(graph)-1:
                result.append(path)
            else:
                for  i in graph[index]:
                    dfs(i,path+[i])
        dfs(0,[0])
        return result

c++程式碼：

class Solution {
public:
    vector<vector<int>> result;
    int len_graph;
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
        len_graph=graph.size();
        vector<int> path={0};
        dfs(0,path,graph);
        return result;
    }
    void dfs(int index,vector<int>&path,vector<vector<int>>& graph)
    {
        if (index==len_graph-1)
            result.push_back(path);
        else
        {
            for(auto i:graph[index])
            {
                //回溯法
                path.push_back(i);
                dfs(i,path,graph);
                path.pop_back();
            }
        }
    }
};

總結：
如果所需要的變數已經有了，儘量直接使用而不是通過別的方式再得到所需要的變數，這樣能節省大量的時間。