solves #797: All Paths From Source to Target in java

Author: anishLearnsToCode

Diff for: README.md

@@ -414,6 +414,7 @@
 | 783  | [Minimum Distance Between BST Nodes](https://leetcode.com/problems/minimum-distance-between-bst-nodes)                                                                 |                                         [![Java](assets/java.png)](src/MinimumAbsoluteDifferenceInBST.java) [![Python](assets/python.png)](python/minimum_distance_between_bst_nodes.py)                                         |                                                                                                                                   |
 | 788  | [Rotated Digits](https://leetcode.com/problems/rotated-digits)                                                                                                         |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 796  | [Rotate String](https://leetcode.com/problems/rotate-string)                                                                                                           |                                                                                        [![Java](assets/java.png)](src/RotateString.java)                                                                                         |                                                                                                                                   |
+| 797  | [All Paths From Source to Target](https://leetcode.com/problems/all-paths-from-source-to-target)                                                                       |                                                                                 [![Java](assets/java.png)](src/AllPathsFromSourceToTarget.java)                                                                                  |                                                                                                                                   |
 | 800  | [Similar RGB Color](https://leetcode.com/problems/similar-rgb-color)                                                                                                   |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 804  | [Unique Morse Code Words](https://leetcode.com/problems/unique-morse-code-words)                                                                                       |                                                                                    [![Java](assets/java.png)](src/UniqueMorseCodeWords.java)                                                                                     |                                                                                                                                   |
 | 806  | [Number of Lines to Write String](https://leetcode.com/problems/number-of-lines-to-write-string)                                                                       |                                                                                [![Java](assets/java.png)](src/NumberOfLinesToWriteInString.java)                                                                                 |                                                                                                                                   |

Diff for: src/AllPathsFromSourceToTarget.java

@@ -0,0 +1,28 @@
+// https://leetcode.com/problems/all-paths-from-source-to-target
+// maximum edges for DAG = V-1, possible paths = 2^(V-1), for every path we clone path O(V)
+// T: O(2^V * V)
+// S: O(V)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AllPathsFromSourceToTarget {
+    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
+        final List<List<Integer>> result = new ArrayList<>();
+        final int n = graph.length;
+        dfs(graph, 0, n - 1, new ArrayList<>() {{ add(0); }}, result);
+        return result;
+    }
+
+    private static void dfs(int[][] graph, int current, int target, List<Integer> path, List<List<Integer>> result) {
+        if (current == target) {
+            result.add(new ArrayList<>(path));
+            return;
+        }
+        for (int edge : graph[current]) {
+            path.add(edge);
+            dfs(graph, edge, target, path, result);
+            path.removeLast();
+        }
+    }
+}

Diff for: src/HelloWorld.java

@@ -1,2 +1,51 @@
+// T: O(N + E alp(N))
+// S: O(N)
+
 public class HelloWorld {
+    private static final class DisjointSet {
+        private final int[] roots, rank;
+
+        public DisjointSet(int size) {
+            roots = new int[size];
+            rank = new int[size];
+            for (int i = 0 ; i < size ; i++) {
+                roots[i] = i;
+                rank[i] = 1;
+            }
+        }
+
+        public int find(int num) {
+            if (num == roots[num]) {
+                return num;
+            }
+            return roots[num] = find(roots[num]);
+        }
+
+        public boolean areConnected(int x, int y) {
+            return find(x) == find(y);
+        }
+
+        public void union(int x, int y) {
+            final int rootX = find(x), rootY = find(y);
+            if (rootX == rootY) {
+                return;
+            }
+            if (rank[rootX] > rank[rootY]) {
+                roots[rootY] = rootX;
+            } else if (rank[rootX] < rank[rootY]) {
+                roots[rootX] = rootY;
+            } else {
+                roots[rootY] = rootX;
+                rank[rootX]++;
+            }
+        }
+    }
+
+    public boolean validPath(int n, int[][] edges, int source, int destination) {
+        final DisjointSet disjointSet = new DisjointSet(n);
+        for (int[] edge : edges) {
+            disjointSet.union(edge[0], edge[1]);
+        }
+        return disjointSet.areConnected(source, destination);
+    }
 }