[Swift]LeetCode797. 所有可能的路径 | All Paths From Source to Target

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10547365.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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.

---

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

二维数组的第 i 个数组中的单元都表示有向图中 i 号结点所能到达的下一些结点（译者注：有向图是有方向的，即规定了a→b你就不能从b→a）空就是没有下一个结点了。

示例:
输入: [[1,2], [3], [3], []] 
输出: [[0,1,3],[0,2,3]] 
解释: 图是这样的:
0--->1
|    |
v    v
2--->3
这有两条路: 0 -> 1 -> 3 和 0 -> 2 -> 3.

提示:

• 结点的数量会在范围 [2, 15] 内。
• 你可以把路径以任意顺序输出，但在路径内的结点的顺序必须保证。

---

84ms

class Solution {
    func allPathsSourceTarget(_ graph: [[Int]]) -> [[Int]] {
        
        var result : [[Int]] = []
        addPath([0], from: graph, graph, &result)
    
        return result
    }
    func addPath(_ current : [Int] , from graph: [[Int]] , _ oriGraph:[[Int]], _ store:inout [[Int]]) {
        
        if graph.count == 0 || graph[0].count == 0{
            store.append(current)
            return
        }
        
        for g in graph[0] {
            addPath(current + [g], from: Array(oriGraph[g..<oriGraph.count]), oriGraph, &store)
        }
    }
}

---

132ms

class Solution {
    private var cache = [Int:[[Int]]]()
    private var length = 0
    
    func allPathsSourceTarget(_ graph: [[Int]]) -> [[Int]] {
        var graph = graph; length = graph.count - 1
        cache[length] = [[Int]]()
        defer {
            cache = [Int:[[Int]]]()
        }
        return middleTarget(0,&graph)
    }
    
    private func middleTarget(_ start: Int, _ graph: inout [[Int]]) -> [[Int]] {
        if (cache[start] == nil) {
            var tmpAns = [[Int]]()
            for next in graph[start] {
                if (next == length) {
                    tmpAns.append([start,next])
                } else {
                    for path in middleTarget(next,&graph) {
                        tmpAns.append([start]+path)
                    }
                }
            }
            cache[start] = tmpAns
        }
        return cache[start]!
    }
}

---

140ms

class Solution {
    func allPathsSourceTarget(_ graph: [[Int]]) -> [[Int]] {
        var solution = [[Int]]()
        
        var working = [[0]]
        while !working.isEmpty {
            // Push all working paths one node deeper
            working = helper(graph: graph, working: working)
            
            // These have hit the end so add to solution
            let workingSolutions = working.filter { $0.last == graph.count - 1 }
            solution.append(contentsOf: workingSolutions)
            
            // These haven't reached the end yet
            working = working.filter { $0.last != graph.count - 1 }
        }
        
        return solution
    }
    
    /// Push all paths forward one node
    /// Prune all paths that are dead ends/ don't lead to last node
    func helper(graph: [[Int]], working: [[Int]]) -> [[Int]] {
        var newWorking = [[Int]]()
        
        for w in working {
            guard let currentNode = w.last,
                currentNode < graph.count else {
                continue
            }
            
            let nextNodes = graph[currentNode]
            guard !nextNodes.isEmpty else {
                continue
            }
            
            for node in nextNodes {
                var newPath = w
                newPath.append(node)
                
                newWorking.append(newPath)
            }
        }
        
        return newWorking
    }
}

---

144ms

class Solution {
    func allPathsSourceTarget(_ graph: [[Int]]) -> [[Int]] {
    var array: [[Int]] = []
    var path = [0]
    findPath(with: graph, index: 0, result: &array, path: &path)
    return array
}

func findPath(with graph:[[Int]], index: Int, result: inout [[Int]], path: inout [Int]) {
    guard index != graph.count - 1 else {
        result.append(path)
        return
    }
    for i in graph[index] {
        var tempPath = path + [i]
        findPath(with: graph, index: i, result: &result, path: &tempPath)
    }
  }
}

---

156ms

class Solution {
    func allPathsSourceTarget(_ graph: [[Int]]) -> [[Int]] {    
        return nextPosition(graph, visited:[0])
    }

    func nextPosition(_ graph:[[Int]], visited:[Int]) -> [[Int]] {
        var results = [[Int]]()
        var latestPosition = visited.last!
        if latestPosition == graph.count - 1 {
            results.append(visited)
        } else {
            for position in graph[visited.last!] {
                if visited.contains(position) {
                    continue
                } else {
                    var visited_new = visited
                    visited_new.append(position)
                    results += nextPosition(graph, visited: visited_new)
                }
            }
        }
        return results
    }
}

---

164ms

class Solution {   
    func allPathsSourceTarget(_ graph: [[Int]]) -> [[Int]] {
        var results = [[Int]]()
        search(graph.count - 1, [0], 0, graph, &results)
        return results
    }
    
     func search(_ target: Int,
                _ path: [Int], 
                _ currentNode: Int, 
                _ graph: [[Int]], 
                _ results: inout [[Int]]) {
        if currentNode == target {
            results.append(path)
            return
        }
        for nextNode in graph[currentNode] {
                search(target, 
                   path + [nextNode], 
                   nextNode, graph, 
                   &results)
        }
    }
}

---

Runtime: 168 ms

Memory Usage: 20.7 MB

class Solution {
    func allPathsSourceTarget(_ graph: [[Int]]) -> [[Int]] {
        var graph = graph
        return helper(&graph, 0)
    }
    
    func helper(_ graph:inout [[Int]],_ cur:Int) -> [[Int]]
    {
        if cur == graph.count - 1
        {
            return [[graph.count - 1]]
        }
        var res:[[Int]] = [[Int]]()
        for neigh in graph[cur]
        {
            var arr:[[Int]] = helper(&graph, neigh)
            for i in 0..<arr.count
            {
                var path:[Int] = arr[i]
                path.insert(cur,at:0);
                res.append(path);
            }                
        }
        return res
    }
}

---

208ms

class Solution {
    func allPathsSourceTarget(_ graph: [[Int]]) -> [[Int]] {
        return dfs(0, graph)
    }
    
    private func dfs(_ node: Int, _ graph: [[Int]]) -> [[Int]] {
        var result = [[Int]]()
        if node == (graph.count - 1) {
            return [[node]]
        }
        
        for edge in graph[node] {
            let solutions = dfs(edge, graph)
            for sol in solutions {
                result.append([node] + sol)
            }
        }
        return result
    }
}