Merge pull request #2596 from imiss-U/master

Update 0098.所有可达路径.md

problems/kamacoder/0098.所有可达路径.md

@@ -422,9 +422,186 @@ int main() {
 ## 其他语言版本
 
 ### Java 
+#### 邻接矩阵写法
+```java
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
 
+public class Main {
+    static List<List<Integer>> result = new ArrayList<>(); // 收集符合条件的路径
+    static List<Integer> path = new ArrayList<>(); // 1节点到终点的路径
+
+    public static void dfs(int[][] graph, int x, int n) {
+        // 当前遍历的节点x 到达节点n
+        if (x == n) { // 找到符合条件的一条路径
+            result.add(new ArrayList<>(path));
+            return;
+        }
+        for (int i = 1; i <= n; i++) { // 遍历节点x链接的所有节点
+            if (graph[x][i] == 1) { // 找到 x链接的节点
+                path.add(i); // 遍历到的节点加入到路径中来
+                dfs(graph, i, n); // 进入下一层递归
+                path.remove(path.size() - 1); // 回溯，撤销本节点
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int n = scanner.nextInt();
+        int m = scanner.nextInt();
+
+        // 节点编号从1到n，所以申请 n+1 这么大的数组
+        int[][] graph = new int[n + 1][n + 1];
+
+        for (int i = 0; i < m; i++) {
+            int s = scanner.nextInt();
+            int t = scanner.nextInt();
+            // 使用邻接矩阵表示无向图，1 表示 s 与 t 是相连的
+            graph[s][t] = 1;
+        }
+
+        path.add(1); // 无论什么路径已经是从1节点出发
+        dfs(graph, 1, n); // 开始遍历
+
+        // 输出结果
+        if (result.isEmpty()) System.out.println(-1);
+        for (List<Integer> pa : result) {
+            for (int i = 0; i < pa.size() - 1; i++) {
+                System.out.print(pa.get(i) + " ");
+            }
+            System.out.println(pa.get(pa.size() - 1));
+        }
+    }
+}
+```  
+
+#### 邻接表写法
+```java
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Scanner;
+
+public class Main {
+    static List<List<Integer>> result = new ArrayList<>(); // 收集符合条件的路径
+    static List<Integer> path = new ArrayList<>(); // 1节点到终点的路径
+
+    public static void dfs(List<LinkedList<Integer>> graph, int x, int n) {
+        if (x == n) { // 找到符合条件的一条路径
+            result.add(new ArrayList<>(path));
+            return;
+        }
+        for (int i : graph.get(x)) { // 找到 x指向的节点
+            path.add(i); // 遍历到的节点加入到路径中来
+            dfs(graph, i, n); // 进入下一层递归
+            path.remove(path.size() - 1); // 回溯，撤销本节点
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int n = scanner.nextInt();
+        int m = scanner.nextInt();
+
+        // 节点编号从1到n，所以申请 n+1 这么大的数组
+        List<LinkedList<Integer>> graph = new ArrayList<>(n + 1);
+        for (int i = 0; i <= n; i++) {
+            graph.add(new LinkedList<>());
+        }
+
+        while (m-- > 0) {
+            int s = scanner.nextInt();
+            int t = scanner.nextInt();
+            // 使用邻接表表示 s -> t 是相连的
+            graph.get(s).add(t);
+        }
+
+        path.add(1); // 无论什么路径已经是从1节点出发
+        dfs(graph, 1, n); // 开始遍历
+
+        // 输出结果
+        if (result.isEmpty()) System.out.println(-1);
+        for (List<Integer> pa : result) {
+            for (int i = 0; i < pa.size() - 1; i++) {
+                System.out.print(pa.get(i) + " ");
+            }
+            System.out.println(pa.get(pa.size() - 1));
+        }
+    }
+}
+```
 ### Python
+#### 邻接矩阵写法
+``` python
+def dfs(graph, x, n, path, result):
+    if x == n:
+        result.append(path.copy())
+        return
+    for i in range(1, n + 1):
+        if graph[x][i] == 1:
+            path.append(i)
+            dfs(graph, i, n, path, result)
+            path.pop()
 
+def main():
+    n, m = map(int, input().split())
+    graph = [[0] * (n + 1) for _ in range(n + 1)]
+
+    for _ in range(m):
+        s, t = map(int, input().split())
+        graph[s][t] = 1
+
+    result = []
+    dfs(graph, 1, n, [1], result)
+
+    if not result:
+        print(-1)
+    else:
+        for path in result:
+            print(' '.join(map(str, path)))
+
+if __name__ == "__main__":
+    main()
+```  
+
+#### 邻接表写法
+``` python
+from collections import defaultdict
+
+result = []  # 收集符合条件的路径
+path = []  # 1节点到终点的路径
+
+def dfs(graph, x, n):
+    if x == n:  # 找到符合条件的一条路径
+        result.append(path.copy())
+        return
+    for i in graph[x]:  # 找到 x指向的节点
+        path.append(i)  # 遍历到的节点加入到路径中来
+        dfs(graph, i, n)  # 进入下一层递归
+        path.pop()  # 回溯，撤销本节点
+
+def main():
+    n, m = map(int, input().split())
+
+    graph = defaultdict(list)  # 邻接表
+    for _ in range(m):
+        s, t = map(int, input().split())
+        graph[s].append(t)
+
+    path.append(1)  # 无论什么路径已经是从1节点出发
+    dfs(graph, 1, n)  # 开始遍历
+
+    # 输出结果
+    if not result:
+        print(-1)
+    for pa in result:
+        print(' '.join(map(str, pa)))
+
+if __name__ == "__main__":
+    main()
+```
 ### Go
 
 ### Rust