Added tags

Author: javadev

src/main/java/g3301_3400/s3340_check_balanced_string/Solution.java

@@ -1,6 +1,6 @@
 package g3301_3400.s3340_check_balanced_string;
 
-// #Easy #2024_11_04_Time_0_ms_(100.00%)_Space_42.1_MB_(100.00%)
+// #Easy #String #2024_11_05_Time_1_ms_(99.60%)_Space_42_MB_(79.77%)
 
 public class Solution {
     public boolean isBalanced(String num) {

src/main/java/g3301_3400/s3341_find_minimum_time_to_reach_last_room_i/Solution.java

@@ -1,6 +1,7 @@
 package g3301_3400.s3341_find_minimum_time_to_reach_last_room_i;
 
-// #Medium #2024_11_04_Time_8_ms_(100.00%)_Space_45.3_MB_(100.00%)
+// #Medium #Array #Matrix #Heap_Priority_Queue #Graph #Shortest_Path
+// #2024_11_05_Time_8_ms_(67.58%)_Space_45.4_MB_(19.79%)
 
 import java.util.Arrays;
 import java.util.Comparator;

src/main/java/g3301_3400/s3342_find_minimum_time_to_reach_last_room_ii/Solution.java

@@ -1,43 +1,50 @@
 package g3301_3400.s3342_find_minimum_time_to_reach_last_room_ii;
 
-// #Medium #2024_11_04_Time_573_ms_(100.00%)_Space_127_MB_(100.00%)
+// #Medium #Array #Matrix #Heap_Priority_Queue #Graph #Shortest_Path
+// #2024_11_05_Time_495_ms_(37.48%)_Space_126.6_MB_(8.65%)
 
-import java.util.Arrays;
-import java.util.Comparator;
 import java.util.PriorityQueue;
 
 public class Solution {
+    private static class Node {
+        int x;
+        int y;
+        int t;
+        int turn;
+    }
+
+    private final int[][] dir = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+
     public int minTimeToReach(int[][] moveTime) {
-        int n = moveTime.length;
-        int m = moveTime[0].length;
-        int inf = Integer.MAX_VALUE;
-        int[][] dp = new int[n][m];
-        for (int i = 0; i < n; i++) {
-            Arrays.fill(dp[i], inf);
-        }
-        PriorityQueue<int[]> h = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
-        // arrive time, i, j
-        h.offer(new int[] {0, 0, 0});
+        PriorityQueue<Node> pq = new PriorityQueue<>((a, b) -> a.t - b.t);
+        int m = moveTime.length;
+        int n = moveTime[0].length;
+        Node node = new Node();
+        node.x = 0;
+        node.y = 0;
+        int t = 0;
+        node.t = t;
+        node.turn = 0;
+        pq.add(node);
         moveTime[0][0] = -1;
-        while (!h.isEmpty()) {
-            int[] cur = h.poll();
-            int t = cur[0];
-            int i = cur[1];
-            int j = cur[2];
-            if (t >= dp[i][j]) {
-                continue;
-            }
-            if (i == n - 1 && j == m - 1) {
-                return t;
-            }
-            dp[i][j] = t;
-            int[][] dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-            for (int[] dir : dirs) {
-                int x = i + dir[0];
-                int y = j + dir[1];
-                int c = (i + j) % 2 + 1;
-                if (0 <= x && x < n && 0 <= y && y < m && dp[x][y] == inf) {
-                    h.offer(new int[] {Math.max(moveTime[x][y], t) + c, x, y});
+        while (!pq.isEmpty()) {
+            Node curr = pq.poll();
+            for (int i = 0; i < 4; i++) {
+                int x = curr.x + dir[i][0];
+                int y = curr.y + dir[i][1];
+                if (x == m - 1 && y == n - 1) {
+                    t = Math.max(curr.t, moveTime[x][y]) + 1 + curr.turn;
+                    return t;
+                }
+                if (x >= 0 && x < m && y < n && y >= 0 && moveTime[x][y] != -1) {
+                    Node newNode = new Node();
+                    t = Math.max(curr.t, moveTime[x][y]) + 1 + curr.turn;
+                    newNode.x = x;
+                    newNode.y = y;
+                    newNode.t = t;
+                    newNode.turn = curr.turn == 1 ? 0 : 1;
+                    pq.add(newNode);
+                    moveTime[x][y] = -1;
                 }
             }
         }

src/main/java/g3301_3400/s3343_count_number_of_balanced_permutations/Solution.java

@@ -1,6 +1,7 @@
 package g3301_3400.s3343_count_number_of_balanced_permutations;
 
-// #Hard #2024_11_05_Time_61_ms_(97.56%)_Space_44.3_MB_(100.00%)
+// #Hard #String #Dynamic_Programming #Math #Combinatorics
+// #2024_11_05_Time_64_ms_(85.37%)_Space_44.8_MB_(95.12%)
 
 public class Solution {
     private static final int M = 1000000007;