Merge pull request chipbk10#86 from chipbk10/Graph

Solve Problem 1377 - Frog Position After T Seconds

Author: chipbk10

src/contest/ReadMe.java

@@ -4,9 +4,9 @@ public class ReadMe {
 
     // TOPICS               [v]         [v]         [x]
 
-    // tree:                1339[v]     1325[v]     1379
-    // graph:               997[v]      1361[v]     1043
-    // dfs:                 1319[v]     1254[v]     1377
+    // tree:                1339[v]     1325[v]     1379[v]
+    // graph:               997[v]      1361[v]     1043[v]
+    // dfs:                 1319[v]     1254[v]     1377[v]
     // bfs:                 1345[v]     1368[!]     1311
     // backtrack:           1307[!]     1239[v]     1219
     // dp:                  1349[!]     1340[v]     1367

src/graph/dfs/Problem1377_FrogPositionAfterTSeconds.java

@@ -0,0 +1,45 @@
+package graph.dfs;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class Problem1377_FrogPositionAfterTSeconds {
+
+    List<Integer>[] graph;
+
+    public double frogPosition(int n, int[][] edges, int t, int target) {
+        graph = new LinkedList[n+1];
+        for (int i = 1; i <= n; i++) graph[i] = new LinkedList<>();
+        for (int[] e : edges) {
+            int i = e[0], j = e[1];
+            graph[i].add(j);
+            graph[j].add(i);
+        }
+
+        // edge cases
+        if (graph[1].size() == 0) return (target == 1) ? 1 : 0;
+        if (target == 1) return (graph[1].size() > 0) ? 0 : 1;
+
+        return dfs(0, 1, t, target);
+    }
+
+    private double dfs(int parent, int node, int t, int target) {
+
+        // run out of time
+        if (t == 0) return (node == target) ? 1 : 0;
+
+        // reach the target
+        if (node == target) return (graph[node].size() == 1) ? 1 : 0;
+
+        for (int next : graph[node]) {
+            if (next == parent) continue;
+            double p = dfs(node, next, t-1, target);
+            if (p != 0) {
+                int childNodes = graph[node].size();
+                if (node != 1) childNodes--;
+                return p/childNodes;
+            }
+        }
+        return 0;
+    }
+}