Added tasks 3492-3495

Author: javadev

README.md

@@ -2088,11 +2088,15 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3495 |[Minimum Operations to Make Array Elements Zero](src/main/java/g3401_3500/s3495_minimum_operations_to_make_array_elements_zero)| Hard | Array, Math, Bit_Manipulation | 9 | 99.71
+| 3494 |[Find the Minimum Amount of Time to Brew Potions](src/main/java/g3401_3500/s3494_find_the_minimum_amount_of_time_to_brew_potions)| Medium | Array, Simulation, Prefix_Sum | 113 | 90.95
+| 3493 |[Properties Graph](src/main/java/g3401_3500/s3493_properties_graph)| Medium | Array, Hash_Table, Depth_First_Search, Breadth_First_Search, Graph, Union_Find | 27 | 99.82
+| 3492 |[Maximum Containers on a Ship](src/main/java/g3401_3500/s3492_maximum_containers_on_a_ship)| Easy | Math | 0 | 100.00
 | 3490 |[Count Beautiful Numbers](src/main/java/g3401_3500/s3490_count_beautiful_numbers)| Hard | Dynamic_Programming | 523 | 100.00
 | 3489 |[Zero Array Transformation IV](src/main/java/g3401_3500/s3489_zero_array_transformation_iv)| Medium | Array, Dynamic_Programming | 142 | 100.00
 | 3488 |[Closest Equal Element Queries](src/main/java/g3401_3500/s3488_closest_equal_element_queries)| Medium | Array, Hash_Table, Binary_Search | 50 | 100.00
 | 3487 |[Maximum Unique Subarray Sum After Deletion](src/main/java/g3401_3500/s3487_maximum_unique_subarray_sum_after_deletion)| Easy | Array, Hash_Table, Greedy | 2 | 100.00
-| 3486 |[Longest Special Path II](src/main/java/g3401_3500/s3486_longest_special_path_ii)| Hard | Array, Hash_Table, Tree, Prefix_Sum, Depth_First_Search | 166 | 166 ms ( %)
+| 3486 |[Longest Special Path II](src/main/java/g3401_3500/s3486_longest_special_path_ii)| Hard | Array, Hash_Table, Depth_First_Search, Tree, Prefix_Sum | 166 | 100.00
 | 3485 |[Longest Common Prefix of K Strings After Removal](src/main/java/g3401_3500/s3485_longest_common_prefix_of_k_strings_after_removal)| Hard | Array, String, Trie | 333 | 100.00
 | 3484 |[Design Spreadsheet](src/main/java/g3401_3500/s3484_design_spreadsheet)| Medium | Array, String, Hash_Table, Matrix, Design | 117 | 100.00
 | 3483 |[Unique 3-Digit Even Numbers](src/main/java/g3401_3500/s3483_unique_3_digit_even_numbers)| Easy | Array, Hash_Table, Recursion, Enumeration | 5 | 100.00
@@ -2259,7 +2263,7 @@
 | 3287 |[Find the Maximum Sequence Value of Array](src/main/java/g3201_3300/s3287_find_the_maximum_sequence_value_of_array)| Hard | Array, Dynamic_Programming, Bit_Manipulation | 1140 | 100.00
 | 3286 |[Find a Safe Walk Through a Grid](src/main/java/g3201_3300/s3286_find_a_safe_walk_through_a_grid)| Medium | Array, Breadth_First_Search, Matrix, Heap_Priority_Queue, Graph, Shortest_Path | 90 | 100.00
 | 3285 |[Find Indices of Stable Mountains](src/main/java/g3201_3300/s3285_find_indices_of_stable_mountains)| Easy | Array | 1 | 100.00
-| 3283 |[Maximum Number of Moves to Kill All Pawns](src/main/java/g3201_3300/s3283_maximum_number_of_moves_to_kill_all_pawns)| Hard | Array, Math, Breadth_First_Search, Bit_Manipulation, Bitmask, Game_Theory | 250 | 98.43
+| 3283 |[Maximum Number of Moves to Kill All Pawns](src/main/java/g3201_3300/s3283_maximum_number_of_moves_to_kill_all_pawns)| Hard | Array, Math, Breadth_First_Search, Bit_Manipulation, Bitmask, Game_Theory | 126 | 100.00
 | 3282 |[Reach End of Array With Max Score](src/main/java/g3201_3300/s3282_reach_end_of_array_with_max_score)| Medium | Array, Greedy | 9 | 100.00
 | 3281 |[Maximize Score of Numbers in Ranges](src/main/java/g3201_3300/s3281_maximize_score_of_numbers_in_ranges)| Medium | Array, Sorting, Greedy, Binary_Search | 47 | 100.00
 | 3280 |[Convert Date to Binary](src/main/java/g3201_3300/s3280_convert_date_to_binary)| Easy | String, Math | 3 | 100.00
@@ -3087,7 +3091,7 @@
 | 2217 |[Find Palindrome With Fixed Length](src/main/java/g2201_2300/s2217_find_palindrome_with_fixed_length)| Medium | Array, Math | 37 | 88.60
 | 2216 |[Minimum Deletions to Make Array Beautiful](src/main/java/g2201_2300/s2216_minimum_deletions_to_make_array_beautiful)| Medium | Array, Greedy, Stack | 7 | 39.24
 | 2215 |[Find the Difference of Two Arrays](src/main/java/g2201_2300/s2215_find_the_difference_of_two_arrays)| Easy | Array, Hash_Table | 11 | 87.39
-| 2213 |[Longest Substring of One Repeating Character](src/main/java/g2201_2300/s2213_longest_substring_of_one_repeating_character)| Hard | Array, String, Ordered_Set, Segment_Tree | 141 | 86.81
+| 2213 |[Longest Substring of One Repeating Character](src/main/java/g2201_2300/s2213_longest_substring_of_one_repeating_character)| Hard | Array, String, Ordered_Set, Segment_Tree | 79 | 89.74
 | 2212 |[Maximum Points in an Archery Competition](src/main/java/g2201_2300/s2212_maximum_points_in_an_archery_competition)| Medium | Array, Bit_Manipulation, Recursion, Enumeration | 7 | 78.16
 | 2211 |[Count Collisions on a Road](src/main/java/g2201_2300/s2211_count_collisions_on_a_road)| Medium | String, Stack | 113 | 45.96
 | 2210 |[Count Hills and Valleys in an Array](src/main/java/g2201_2300/s2210_count_hills_and_valleys_in_an_array)| Easy | Array | 0 | 100.00

src/main/java/g2201_2300/s2213_longest_substring_of_one_repeating_character/readme.md

@@ -50,90 +50,70 @@ Thus, we return [2,3].
 
 ```java
 public class Solution {
-    static class TreeNode {
-        int start;
-        int end;
-        char leftChar;
-        int leftCharLen;
-        char rightChar;
-        int rightCharLen;
-        int max;
-        TreeNode left;
-        TreeNode right;
-
-        TreeNode(int start, int end) {
-            this.start = start;
-            this.end = end;
-            left = null;
-            right = null;
-        }
-    }
+    private char[] ca;
 
     public int[] longestRepeating(String s, String queryCharacters, int[] queryIndices) {
-        char[] sChar = s.toCharArray();
-        char[] qChar = queryCharacters.toCharArray();
-        TreeNode root = buildTree(sChar, 0, sChar.length - 1);
-        int[] result = new int[qChar.length];
-        for (int i = 0; i < qChar.length; i++) {
-            updateTree(root, queryIndices[i], qChar[i]);
-            if (root != null) {
-                result[i] = root.max;
-            }
+        ca = s.toCharArray();
+        int[] result = new int[queryIndices.length];
+        SegmentTree root = new SegmentTree(0, ca.length);
+        for (int i = 0; i < queryIndices.length; i++) {
+            ca[queryIndices[i]] = queryCharacters.charAt(i);
+            root.update(queryIndices[i]);
+            result[i] = root.longest;
         }
         return result;
     }
 
-    private TreeNode buildTree(char[] s, int from, int to) {
-        if (from > to) {
-            return null;
-        }
-        TreeNode root = new TreeNode(from, to);
-        if (from == to) {
-            root.max = 1;
-            root.rightChar = root.leftChar = s[from];
-            root.leftCharLen = root.rightCharLen = 1;
-            return root;
-        }
-        int middle = from + (to - from) / 2;
-        root.left = buildTree(s, from, middle);
-        root.right = buildTree(s, middle + 1, to);
-        updateNode(root);
-        return root;
-    }
+    private class SegmentTree {
+        final int start;
+        final int end;
+        int longest;
+        int leftLength;
+        int rightLength;
+        SegmentTree left;
+        SegmentTree right;
 
-    private void updateTree(TreeNode root, int index, char c) {
-        if (root == null || root.start > index || root.end < index) {
-            return;
-        }
-        if (root.start == index && root.end == index) {
-            root.leftChar = root.rightChar = c;
-            return;
+        SegmentTree(int start, int end) {
+            this.start = start;
+            this.end = end;
+            if (end - start > 1) {
+                int mid = (start + end) / 2;
+                left = new SegmentTree(start, mid);
+                right = new SegmentTree(mid, end);
+                merge();
+            } else {
+                longest = leftLength = rightLength = 1;
+            }
         }
-        updateTree(root.left, index, c);
-        updateTree(root.right, index, c);
-        updateNode(root);
-    }
 
-    private void updateNode(TreeNode root) {
-        if (root == null) {
-            return;
-        }
-        root.leftChar = root.left.leftChar;
-        root.leftCharLen = root.left.leftCharLen;
-        root.rightChar = root.right.rightChar;
-        root.rightCharLen = root.right.rightCharLen;
-        root.max = Math.max(root.left.max, root.right.max);
-        if (root.left.rightChar == root.right.leftChar) {
-            int len = root.left.rightCharLen + root.right.leftCharLen;
-            if (root.left.leftChar == root.left.rightChar
-                    && root.left.leftCharLen == root.left.end - root.left.start + 1) {
-                root.leftCharLen = len;
+        void update(int index) {
+            if (end - start == 1) {
+                return;
+            }
+            if (index < left.end) {
+                left.update(index);
+            } else {
+                right.update(index);
             }
-            if (root.right.leftChar == root.right.rightChar
-                    && root.right.leftCharLen == root.right.end - root.right.start + 1) {
-                root.rightCharLen = len;
+            merge();
+        }
+
+        private void merge() {
+            longest = Math.max(left.longest, right.longest);
+            if (ca[left.end - 1] == ca[right.start]) {
+                longest = Math.max(longest, left.rightLength + right.leftLength);
+                leftLength =
+                        (left.leftLength == left.end - left.start)
+                                ? left.leftLength + right.leftLength
+                                : left.leftLength;
+                rightLength =
+                        (right.rightLength == right.end - right.start)
+                                ? right.rightLength + left.rightLength
+                                : right.rightLength;
+            } else {
+                leftLength = left.leftLength;
+                rightLength = right.rightLength;
             }
-            root.max = Math.max(root.max, len);
         }
     }
 }

src/main/java/g3201_3300/s3283_maximum_number_of_moves_to_kill_all_pawns/readme.md

@@ -69,85 +69,97 @@ The knight takes 4 moves to reach the pawn at `(0, 0)`.
 ## Solution
 
 ```java
-import java.util.LinkedList;
+import java.util.ArrayDeque;
 import java.util.Queue;
 
 public class Solution {
-    private static final int[][] KNIGHT_MOVES = {
-        {-2, -1}, {-2, 1}, {-1, -2}, {-1, 2},
-        {1, -2}, {1, 2}, {2, -1}, {2, 1}
+    private static final int[][] DIRECTIONS = {
+        {2, 1}, {1, 2}, {-1, 2}, {-2, 1}, {-2, -1}, {-1, -2}, {1, -2}, {2, -1}
     };
-    private int[][] distances;
-    private Integer[][] memo;
 
-    public int maxMoves(int kx, int ky, int[][] positions) {
+    private void initializePositions(int[][] positions, int[][] pos, int kx, int ky) {
         int n = positions.length;
-        distances = new int[n + 1][n + 1];
-        memo = new Integer[n + 1][1 << n];
-        // Calculate distances between all pairs of positions (including knight's initial position)
         for (int i = 0; i < n; i++) {
-            distances[n][i] = calculateMoves(kx, ky, positions[i][0], positions[i][1]);
-            for (int j = i + 1; j < n; j++) {
-                int dist =
-                        calculateMoves(
-                                positions[i][0], positions[i][1], positions[j][0], positions[j][1]);
-                distances[i][j] = distances[j][i] = dist;
-            }
+            int x = positions[i][0];
+            int y = positions[i][1];
+            pos[x][y] = i;
         }
-        return minimax(n, (1 << n) - 1, true);
+        pos[kx][ky] = n;
     }
 
-    private int minimax(int lastPos, int remainingPawns, boolean isAlice) {
-        if (remainingPawns == 0) {
-            return 0;
-        }
-        if (memo[lastPos][remainingPawns] != null) {
-            return memo[lastPos][remainingPawns];
-        }
-        int result = isAlice ? 0 : Integer.MAX_VALUE;
-        for (int i = 0; i < distances.length - 1; i++) {
-            if ((remainingPawns & (1 << i)) != 0) {
-                int newRemainingPawns = remainingPawns & ~(1 << i);
-                int moveValue = distances[lastPos][i] + minimax(i, newRemainingPawns, !isAlice);
-
-                if (isAlice) {
-                    result = Math.max(result, moveValue);
-                } else {
-                    result = Math.min(result, moveValue);
+    private void calculateDistances(int[][] positions, int[][] pos, int[][] distances) {
+        int n = positions.length;
+        for (int i = 0; i < n; i++) {
+            int count = n - i;
+            boolean[][] visited = new boolean[50][50];
+            visited[positions[i][0]][positions[i][1]] = true;
+            Queue<int[]> que = new ArrayDeque<>();
+            que.offer(new int[] {positions[i][0], positions[i][1]});
+            int steps = 1;
+            while (!que.isEmpty() && count > 0) {
+                int size = que.size();
+                while (size-- > 0) {
+                    int[] cur = que.poll();
+                    int x = cur[0];
+                    int y = cur[1];
+                    for (int[] d : DIRECTIONS) {
+                        int nx = x + d[0];
+                        int ny = y + d[1];
+                        if (0 <= nx && nx < 50 && 0 <= ny && ny < 50 && !visited[nx][ny]) {
+                            que.offer(new int[] {nx, ny});
+                            visited[nx][ny] = true;
+                            int j = pos[nx][ny];
+                            if (j > i) {
+                                distances[i][j] = distances[j][i] = steps;
+                                if (--count == 0) {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (count == 0) {
+                        break;
+                    }
                 }
+                steps++;
             }
         }
-        memo[lastPos][remainingPawns] = result;
-        return result;
     }
 
-    private int calculateMoves(int x1, int y1, int x2, int y2) {
-        if (x1 == x2 && y1 == y2) {
-            return 0;
-        }
-        boolean[][] visited = new boolean[50][50];
-        Queue<int[]> queue = new LinkedList<>();
-        queue.offer(new int[] {x1, y1, 0});
-        visited[x1][y1] = true;
-        while (!queue.isEmpty()) {
-            int[] current = queue.poll();
-            int x = current[0];
-            int y = current[1];
-            int moves = current[2];
-            for (int[] move : KNIGHT_MOVES) {
-                int nx = x + move[0];
-                int ny = y + move[1];
-                if (nx == x2 && ny == y2) {
-                    return moves + 1;
-                }
-                if (nx >= 0 && nx < 50 && ny >= 0 && ny < 50 && !visited[nx][ny]) {
-                    queue.offer(new int[] {nx, ny, moves + 1});
-                    visited[nx][ny] = true;
+    private int calculateDP(int n, int[][] distances) {
+        int m = (1 << n) - 1;
+        int[][] dp = new int[1 << n][n + 1];
+        for (int mask = 1; mask < (1 << n); mask++) {
+            boolean isEven = (Integer.bitCount(m ^ mask)) % 2 == 0;
+            for (int i = 0; i <= n; i++) {
+                int result = 0;
+                if (isEven) {
+                    for (int j = 0; j < n; j++) {
+                        if ((mask & (1 << j)) > 0) {
+                            result = Math.max(result, dp[mask ^ (1 << j)][j] + distances[i][j]);
+                        }
+                    }
+                } else {
+                    result = Integer.MAX_VALUE;
+                    for (int j = 0; j < n; j++) {
+                        if ((mask & (1 << j)) > 0) {
+                            result = Math.min(result, dp[mask ^ (1 << j)][j] + distances[i][j]);
+                        }
+                    }
                 }
+                dp[mask][i] = result;
             }
         }
-        // Should never reach here if input is valid
-        return -1;
+        return dp[m][n];
+    }
+
+    public int maxMoves(int kx, int ky, int[][] positions) {
+        int n = positions.length;
+        int[][] pos = new int[50][50];
+        initializePositions(positions, pos, kx, ky);
+        int[][] distances = new int[n + 1][n + 1];
+        calculateDistances(positions, pos, distances);
+        return calculateDP(n, distances);
     }
 }
 ```

src/main/java/g3401_3500/s3492_maximum_containers_on_a_ship/readme.md

@@ -0,0 +1,50 @@
+[![](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)
+
+## 3492\. Maximum Containers on a Ship
+
+Easy
+
+You are given a positive integer `n` representing an `n x n` cargo deck on a ship. Each cell on the deck can hold one container with a weight of **exactly** `w`.
+
+However, the total weight of all containers, if loaded onto the deck, must not exceed the ship's maximum weight capacity, `maxWeight`.
+
+Return the **maximum** number of containers that can be loaded onto the ship.
+
+**Example 1:**
+
+**Input:** n = 2, w = 3, maxWeight = 15
+
+**Output:** 4
+
+**Explanation:**
+
+The deck has 4 cells, and each container weighs 3. The total weight of loading all containers is 12, which does not exceed `maxWeight`.
+
+**Example 2:**
+
+**Input:** n = 3, w = 5, maxWeight = 20
+
+**Output:** 4
+
+**Explanation:**
+
+The deck has 9 cells, and each container weighs 5. The maximum number of containers that can be loaded without exceeding `maxWeight` is 4.
+
+**Constraints:**
+
+*   `1 <= n <= 1000`
+*   `1 <= w <= 1000`
+*   <code>1 <= maxWeight <= 10<sup>9</sup></code>
+
+## Solution
+
+```java
+public class Solution {
+    public int maxContainers(int n, int w, int maxWeight) {
+        int c = n * n;
+        int count = maxWeight / w;
+        return Math.min(c, count);
+    }
+}
+```