Added tasks 3340-3343

Author: javadev

README.md

@@ -59,17 +59,16 @@ It is impossible to capture the black queen in less than two moves since it is n
 public class Solution {
     public int minMovesToCaptureTheQueen(int a, int b, int c, int d, int e, int f) {
         if (a == e || b == f) {
-            if (a == c && (d > b && d < f || d > f && d < b)) {
+            if (a == e && a == c && (d - b) * (d - f) < 0) {
                 return 2;
             }
-            if (b == d && (c > a && c < e || c > e && c < a)) {
+            if (b == f && b == d && (c - a) * (c - e) < 0) {
                 return 2;
             }
             return 1;
-        } else if (Math.abs(c - e) == Math.abs(d - f)) {
-            if (Math.abs(a - c) == Math.abs(b - d)
-                    && Math.abs(e - a) == Math.abs(f - b)
-                    && (a > e && a < c || a > c && a < e)) {
+        }
+        if (Math.abs(c - e) == Math.abs(d - f)) {
+            if (Math.abs(c - a) == Math.abs(d - b) && (b - f) * (b - d) < 0) {
                 return 2;
             }
             return 1;

src/main/java/g3001_3100/s3001_minimum_moves_to_capture_the_queen/readme.md

@@ -0,0 +1,54 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3340\. Check Balanced String
+
+Easy
+
+You are given a string `num` consisting of only digits. A string of digits is called **balanced** if the sum of the digits at even indices is equal to the sum of digits at odd indices.
+
+Return `true` if `num` is **balanced**, otherwise return `false`.
+
+**Example 1:**
+
+**Input:** num = "1234"
+
+**Output:** false
+
+**Explanation:**
+
+*   The sum of digits at even indices is `1 + 3 == 4`, and the sum of digits at odd indices is `2 + 4 == 6`.
+*   Since 4 is not equal to 6, `num` is not balanced.
+
+**Example 2:**
+
+**Input:** num = "24123"
+
+**Output:** true
+
+**Explanation:**
+
+*   The sum of digits at even indices is `2 + 1 + 3 == 6`, and the sum of digits at odd indices is `4 + 2 == 6`.
+*   Since both are equal the `num` is balanced.
+
+**Constraints:**
+
+*   `2 <= num.length <= 100`
+*   `num` consists of digits only
+
+## Solution
+
+```java
+public class Solution {
+    public boolean isBalanced(String num) {
+        int diff = 0;
+        int sign = 1;
+        int n = num.length();
+        for (int i = 0; i < n; ++i) {
+            diff += sign * (num.charAt(i) - '0');
+            sign = -sign;
+        }
+        return diff == 0;
+    }
+}
+```

src/main/java/g3301_3400/s3340_check_balanced_string/readme.md

@@ -0,0 +1,98 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3341\. Find Minimum Time to Reach Last Room I
+
+Medium
+
+There is a dungeon with `n x m` rooms arranged as a grid.
+
+You are given a 2D array `moveTime` of size `n x m`, where `moveTime[i][j]` represents the **minimum** time in seconds when you can **start moving** to that room. You start from the room `(0, 0)` at time `t = 0` and can move to an **adjacent** room. Moving between adjacent rooms takes _exactly_ one second.
+
+Return the **minimum** time to reach the room `(n - 1, m - 1)`.
+
+Two rooms are **adjacent** if they share a common wall, either _horizontally_ or _vertically_.
+
+**Example 1:**
+
+**Input:** moveTime = \[\[0,4],[4,4]]
+
+**Output:** 6
+
+**Explanation:**
+
+The minimum time required is 6 seconds.
+
+*   At time `t == 4`, move from room `(0, 0)` to room `(1, 0)` in one second.
+*   At time `t == 5`, move from room `(1, 0)` to room `(1, 1)` in one second.
+
+**Example 2:**
+
+**Input:** moveTime = \[\[0,0,0],[0,0,0]]
+
+**Output:** 3
+
+**Explanation:**
+
+The minimum time required is 3 seconds.
+
+*   At time `t == 0`, move from room `(0, 0)` to room `(1, 0)` in one second.
+*   At time `t == 1`, move from room `(1, 0)` to room `(1, 1)` in one second.
+*   At time `t == 2`, move from room `(1, 1)` to room `(1, 2)` in one second.
+
+**Example 3:**
+
+**Input:** moveTime = \[\[0,1],[1,2]]
+
+**Output:** 3
+
+**Constraints:**
+
+*   `2 <= n == moveTime.length <= 50`
+*   `2 <= m == moveTime[i].length <= 50`
+*   <code>0 <= moveTime[i][j] <= 10<sup>9</sup></code>
+
+## Solution
+
+```java
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public int minTimeToReach(int[][] moveTime) {
+        int rows = moveTime.length;
+        int cols = moveTime[0].length;
+        PriorityQueue<int[]> minHeap = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+        int[][] time = new int[rows][cols];
+        for (int[] row : time) {
+            Arrays.fill(row, Integer.MAX_VALUE);
+        }
+        minHeap.offer(new int[] {0, 0, 0});
+        time[0][0] = 0;
+        int[][] directions = { {1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+        while (!minHeap.isEmpty()) {
+            int[] current = minHeap.poll();
+            int currentTime = current[0];
+            int x = current[1];
+            int y = current[2];
+            if (x == rows - 1 && y == cols - 1) {
+                return currentTime;
+            }
+            for (int[] dir : directions) {
+                int newX = x + dir[0];
+                int newY = y + dir[1];
+                if (newX >= 0 && newX < rows && newY >= 0 && newY < cols) {
+                    int waitTime = Math.max(moveTime[newX][newY] - currentTime, 0);
+                    int newTime = currentTime + 1 + waitTime;
+                    if (newTime < time[newX][newY]) {
+                        time[newX][newY] = newTime;
+                        minHeap.offer(new int[] {newTime, newX, newY});
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+}
+```

src/main/java/g3301_3400/s3341_find_minimum_time_to_reach_last_room_i/readme.md

@@ -0,0 +1,107 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3342\. Find Minimum Time to Reach Last Room II
+
+Medium
+
+There is a dungeon with `n x m` rooms arranged as a grid.
+
+You are given a 2D array `moveTime` of size `n x m`, where `moveTime[i][j]` represents the **minimum** time in seconds when you can **start moving** to that room. You start from the room `(0, 0)` at time `t = 0` and can move to an **adjacent** room. Moving between **adjacent** rooms takes one second for one move and two seconds for the next, **alternating** between the two.
+
+Return the **minimum** time to reach the room `(n - 1, m - 1)`.
+
+Two rooms are **adjacent** if they share a common wall, either _horizontally_ or _vertically_.
+
+**Example 1:**
+
+**Input:** moveTime = \[\[0,4],[4,4]]
+
+**Output:** 7
+
+**Explanation:**
+
+The minimum time required is 7 seconds.
+
+*   At time `t == 4`, move from room `(0, 0)` to room `(1, 0)` in one second.
+*   At time `t == 5`, move from room `(1, 0)` to room `(1, 1)` in two seconds.
+
+**Example 2:**
+
+**Input:** moveTime = \[\[0,0,0,0],[0,0,0,0]]
+
+**Output:** 6
+
+**Explanation:**
+
+The minimum time required is 6 seconds.
+
+*   At time `t == 0`, move from room `(0, 0)` to room `(1, 0)` in one second.
+*   At time `t == 1`, move from room `(1, 0)` to room `(1, 1)` in two seconds.
+*   At time `t == 3`, move from room `(1, 1)` to room `(1, 2)` in one second.
+*   At time `t == 4`, move from room `(1, 2)` to room `(1, 3)` in two seconds.
+
+**Example 3:**
+
+**Input:** moveTime = \[\[0,1],[1,2]]
+
+**Output:** 4
+
+**Constraints:**
+
+*   `2 <= n == moveTime.length <= 750`
+*   `2 <= m == moveTime[i].length <= 750`
+*   <code>0 <= moveTime[i][j] <= 10<sup>9</sup></code>
+
+## Solution
+
+```java
+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) {
+        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 (!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;
+                }
+            }
+        }
+        return -1;
+    }
+}
+```