add 3112

Author: fishercoder1534

Diff for: paginated_contents/algorithms/4th_thousand/README.md

@@ -36,6 +36,7 @@
 | 3131 | [Find the Integer Added to Array I](https://leetcode.com/problems/find-the-integer-added-to-array-i/)                                                               | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3131.java) |                                                                               | Easy       |
 | 3127 | [Make a Square with the Same Color](https://leetcode.com/problems/make-a-square-with-the-same-color/)                                                               | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3127.java) |                                                                               | Easy       |
 | 3120 | [Count the Number of Special Characters I](https://leetcode.com/problems/count-the-number-of-special-characters-i/)                                                 | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3120.java) |                                                                               | Easy       |
+| 3112 | [Minimum Time to Visit Disappearing Nodes](https://leetcode.com/problems/minimum-time-to-visit-disappearing-nodes/)                                                                                               | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3112.java) |                                                                               | Medium     | Graph, Shortest Path
 | 3110 | [Score of a String](https://leetcode.com/problems/score-of-a-string/)                                                                                               | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3110.java) |                                                                               | Easy       |
 | 3095 | [Shortest Subarray With OR at Least K I](https://leetcode.com/problems/shortest-subarray-with-or-at-least-k-i/)                                                     | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3095.java) |                                                                               | Easy       |
 | 3090 | [Maximum Length Substring With Two Occurrences](https://leetcode.com/problems/maximum-length-substring-with-two-occurrences/)                                       | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/fourththousand/_3090.java) |                                                                               | Easy       |

Diff for: src/main/java/com/fishercoder/solutions/fourththousand/_3112.java

@@ -0,0 +1,58 @@
+package com.fishercoder.solutions.fourththousand;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.PriorityQueue;
+
+public class _3112 {
+    public static class Solution1 {
+        /**
+         * My completely original solution: Dijkstra's algorithm!
+         */
+        public int[] minimumTime(int n, int[][] edges, int[] disappear) {
+            List<int[]>[] graph = new ArrayList[n];
+            for (int i = 0; i < n; i++) {
+                graph[i] = new ArrayList<>();
+            }
+            for (int[] edge : edges) {
+                graph[edge[0]].add(new int[]{edge[1], edge[2]});
+                graph[edge[1]].add(new int[]{edge[0], edge[2]});
+            }
+            int[] ans = new int[n];
+            int[] shortestTimes = new int[disappear.length];
+            Arrays.fill(shortestTimes, Integer.MAX_VALUE);
+            shortestTimes[0] = 0;
+            dijkstra(graph, disappear, shortestTimes);
+            for (int target = 1; target < n; target++) {
+                if (shortestTimes[target] == Integer.MAX_VALUE || shortestTimes[target] >= disappear[target]) {
+                    ans[target] = -1;
+                } else {
+                    ans[target] = shortestTimes[target];
+                }
+            }
+            return ans;
+        }
+
+        private void dijkstra(List<int[]>[] graph, int[] disappear, int[] shortestTimes) {
+            PriorityQueue<int[]> q = new PriorityQueue<>((a, b) -> a[1] - b[1]);
+            q.offer(new int[]{0, 0});
+            while (!q.isEmpty()) {
+                int[] curr = q.poll();
+                int currNode = curr[0];
+                int currCost = curr[1];
+                if (currCost > shortestTimes[currNode]) {
+                    continue;
+                }
+                for (int[] neighbor : graph[currNode]) {
+                    int neighborNode = neighbor[0];
+                    int neighborCost = neighbor[1];
+                    if (neighborCost + currCost < shortestTimes[neighborNode] && neighborCost + currCost < disappear[neighborNode]) {
+                        shortestTimes[neighborNode] = neighborCost + currCost;
+                        q.offer(new int[]{neighborNode, shortestTimes[neighborNode]});
+                    }
+                }
+            }
+        }
+    }
+}

Diff for: src/test/java/com/fishercoder/fourththousand/_3112Test.java

@@ -0,0 +1,25 @@
+package com.fishercoder.fourththousand;
+
+import com.fishercoder.common.utils.CommonUtils;
+import com.fishercoder.solutions.fourththousand._3112;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class _3112Test {
+    private static _3112.Solution1 solution1;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _3112.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertArrayEquals(new int[]{0, -1, 4}, solution1
+                .minimumTime(3, CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray
+                                ("[0,1,2],[1,2,1],[0,2,4]"),
+                        new int[]{1, 1, 5}));
+    }
+}