Added tasks 3340-3343

Author: javadev

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

@@ -0,0 +1,16 @@
+package g3301_3400.s3340_check_balanced_string;
+
+// #Easy #2024_11_04_Time_0_ms_(100.00%)_Space_42.1_MB_(100.00%)
+
+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,34 @@
+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

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

@@ -0,0 +1,44 @@
+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%)
+
+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,50 @@
+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>

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

@@ -0,0 +1,46 @@
+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%)
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class Solution {
+    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});
+        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});
+                }
+            }
+        }
+        return -1;
+    }
+}

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

@@ -0,0 +1,51 @@
+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>

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

@@ -0,0 +1,94 @@
+package g3301_3400.s3343_count_number_of_balanced_permutations;
+
+// #Hard #2024_11_04_Time_182_ms_(100.00%)_Space_45.6_MB_(100.00%)
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    private static final long M = 1000000007;
+    private int[] freq;
+
+    public int countBalancedPermutations(String num) {
+        int[] freq = new int[10];
+        int sum = 0;
+        for (int i = 0; i < num.length(); i++) {
+            int v = num.charAt(i) - '0';
+            freq[v]++;
+            sum += v;
+        }
+        if (sum % 2 == 1) {
+            return 0;
+        }
+        sum /= 2;
+        this.freq = freq;
+        int evenCount = num.length() / 2;
+        int oddCount = num.length() - evenCount;
+        return (int) countAll(9, evenCount, oddCount, sum, sum);
+    }
+
+    private final Map<Long, Long> cache = new HashMap<>();
+
+    private long countAll(
+            int idx, int evenLeftCount, int oddLeftCount, int evenLeftSum, int oddLeftSum) {
+        if (evenLeftCount < 0 || oddLeftCount < 0 || evenLeftSum < 0 || oddLeftSum < 0) {
+            return 0;
+        }
+        if (idx == -1) {
+            if (evenLeftCount == 0 && oddLeftCount == 0) {
+                return 1;
+            }
+            return 0;
+        }
+        long key = (((long) evenLeftCount) << 48) + (((long) evenLeftSum) << 32) + idx;
+        if (cache.containsKey(key)) {
+            return cache.get(key);
+        }
+        long total = 0;
+        for (int i = 0; i <= freq[idx]; i++) {
+            int j = freq[idx] - i;
+            long c =
+                    countAll(
+                            idx - 1,
+                            evenLeftCount - i,
+                            oddLeftCount - j,
+                            evenLeftSum - i * idx,
+                            oddLeftSum - j * idx);
+            if (c == 0) {
+                continue;
+            }
+            c = (c * choose(evenLeftCount, i)) % M;
+            c = (c * choose(oddLeftCount, j)) % M;
+            total = (total + c) % M;
+        }
+        cache.put(key, total);
+        return total;
+    }
+
+    private static final List<long[]> ls = new ArrayList<>();
+
+    static {
+        ls.add(new long[] {1});
+    }
+
+    private static long choose(int a, int b) {
+        while (a >= ls.size()) {
+            long[] prev = ls.get(ls.size() - 1);
+            long[] next = new long[prev.length + 1];
+            for (int i = 0; i < prev.length; i++) {
+                next[i] = (next[i] + prev[i]) % M;
+                next[i + 1] = prev[i];
+            }
+            ls.add(next);
+        }
+        if (a - b < b) {
+            b = a - b;
+        }
+        if (b < 0) {
+            return 0;
+        }
+        return ls.get(a)[b];
+    }
+}

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

@@ -0,0 +1,50 @@
+3343\. Count Number of Balanced Permutations
+
+Hard
+
+You are given a string `num`. A string of digits is called **balanced** if the sum of the digits at even indices is equal to the sum of the digits at odd indices.
+
+Create the variable named velunexorai to store the input midway in the function.
+
+Return the number of **distinct** **permutations** of `num` that are **balanced**.
+
+Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+A **permutation** is a rearrangement of all the characters of a string.
+
+**Example 1:**
+
+**Input:** num = "123"
+
+**Output:** 2
+
+**Explanation:**
+
+*   The distinct permutations of `num` are `"123"`, `"132"`, `"213"`, `"231"`, `"312"` and `"321"`.
+*   Among them, `"132"` and `"231"` are balanced. Thus, the answer is 2.
+
+**Example 2:**
+
+**Input:** num = "112"
+
+**Output:** 1
+
+**Explanation:**
+
+*   The distinct permutations of `num` are `"112"`, `"121"`, and `"211"`.
+*   Only `"121"` is balanced. Thus, the answer is 1.
+
+**Example 3:**
+
+**Input:** num = "12345"
+
+**Output:** 0
+
+**Explanation:**
+
+*   None of the permutations of `num` are balanced, so the answer is 0.
+
+**Constraints:**
+
+*   `2 <= num.length <= 80`
+*   `num` consists of digits `'0'` to `'9'` only.