solves #1059: all paths from source lead to destination

Author: anishLearnsToCode

README.md

@@ -493,6 +493,7 @@
 | 1047 | [Remove All adjacent Duplicates in String](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string)                                                     |                                                                            [![Java](assets/java.png)](src/RemoveAllAdjacentDuplicatesInAString.java)                                                                             |                                                                                                                                   |
 | 1051 | [Height Checker](https://leetcode.com/problems/height-checker)                                                                                                         |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 1056 | 🔒 [Confusing Number](https://leetcode.com/problems/confusing-number)                                                                                                  |                                                                                                                                                                                                                                  |                                                                                                                                   |
+| 1059 | 🔒 [All Paths From Source Lead To Destination](https://leetcode.com/problems/all-paths-from-source-lead-to-destination)                                                |                                                                             [![Java](assets/java.png)](src/AllPathsFromSourceLeadToDestination.java)                                                                             |                                                                                                                                   |
 | 1064 | 🔒 [Fixed Point](https://leetcode.com/problems/fixed-point)                                                                                                            |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 1065 | 🔒 [Index Pairs of a String](https://leetcode.com/problems/index-pairs-of-a-string)                                                                                    |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 1071 | [Greatest Common Divisors of Strings](https://leetcode.com/problems/greatest-common-divisor-of-strings)                                                                |                                                                               [![Java](assets/java.png)](src/GreatestCommonDivisorOfStrings.java)                                                                                |                                                                                                                                   |

src/AllPathsFromSourceLeadToDestination.java

@@ -0,0 +1,53 @@
+// https://leetcode.com/problems/all-paths-from-source-lead-to-destination
+// T: O(V + E)
+// S: O(V)
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class AllPathsFromSourceLeadToDestination {
+    // We don't use the state WHITE as such anywhere. Instead, the "null" value in the states array below is a substitute for WHITE.
+    enum Color { GRAY, BLACK };
+
+    public boolean leadsToDestination(int n, int[][] edges, int source, int destination) {
+        Map<Integer, Set<Integer>> graph = buildGraph(edges);
+        return leadsToDestination(graph, source, destination, new Color[n]);
+    }
+
+    private boolean leadsToDestination(Map<Integer, Set<Integer>> graph, int node, int target, Color[] states) {
+        // If the state is GRAY, this is a backward edge and hence, it creates a loop.
+        if (states[node] != null) {
+            return states[node] == Color.BLACK;
+        }
+
+        // If this is a leaf node, it should be equal to the destination.
+        if (!graph.containsKey(node)) {
+            return node == target;
+        }
+
+        // Now, we are processing this node. So we mark it as GRAY
+        states[node] = Color.GRAY;
+
+        for (int next : graph.get(node)) {
+            if (!leadsToDestination(graph, next, target, states)) {
+                return false;
+            }
+        }
+
+        states[node] = Color.BLACK;
+        return true;
+    }
+
+    private Map<Integer, Set<Integer>> buildGraph(int[][] edges) {
+        final Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            final int from = edge[0], to = edge[1];
+            final Set<Integer> neighbours = graph.getOrDefault(from, new HashSet<>());
+            neighbours.add(to);
+            graph.putIfAbsent(from, neighbours);
+        }
+        return graph;
+    }
+}