Improved tags

Author: javadev

src/main/java/g3401_3500/s3446_sort_matrix_by_diagonals/Solution.java

@@ -1,40 +1,42 @@
 package g3401_3500.s3446_sort_matrix_by_diagonals;
 
-// #Medium #2025_02_09_Time_9_ms_(100.00%)_Space_45.62_MB_(100.00%)
+// #Medium #Array #Sorting #Matrix #2025_02_11_Time_3_ms_(94.47%)_Space_45.46_MB_(95.07%)
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.Arrays;
 
-@SuppressWarnings("java:S5413")
 public class Solution {
-    public int[][] sortMatrix(int[][] matrix) {
-        Map<Integer, List<Integer>> diagonalMap = new HashMap<>();
-        int rows = matrix.length;
-        int cols = matrix[0].length;
-        for (int i = 0; i < rows; i++) {
-            for (int j = 0; j < cols; j++) {
-                int key = i - j;
-                diagonalMap.putIfAbsent(key, new ArrayList<>());
-                diagonalMap.get(key).add(matrix[i][j]);
+    public int[][] sortMatrix(int[][] grid) {
+        int top = 0;
+        int left = 0;
+        int right = grid[0].length - 1;
+        while (top < right) {
+            int x = grid[0].length - 1 - left;
+            int[] arr = new int[left + 1];
+            for (int i = top; i <= left; i++) {
+                arr[i] = grid[i][x++];
             }
-        }
-        for (Map.Entry<Integer, List<Integer>> entry : diagonalMap.entrySet()) {
-            List<Integer> values = entry.getValue();
-            if (entry.getKey() < 0) {
-                Collections.sort(values);
-            } else {
-                values.sort(Collections.reverseOrder());
+            Arrays.sort(arr);
+            x = grid[0].length - 1 - left;
+            for (int i = top; i <= left; i++) {
+                grid[i][x++] = arr[i];
             }
+            left++;
+            right--;
         }
-        for (int i = 0; i < rows; i++) {
-            for (int j = 0; j < cols; j++) {
-                int key = i - j;
-                matrix[i][j] = diagonalMap.get(key).remove(0);
+        int bottom = grid.length - 1;
+        int x = 0;
+        while (top <= bottom) {
+            int[] arr = new int[bottom + 1];
+            for (int i = 0; i < arr.length; i++) {
+                arr[i] = grid[x + i][i];
+            }
+            Arrays.sort(arr);
+            for (int i = 0; i < arr.length; i++) {
+                grid[x + i][i] = arr[arr.length - 1 - i];
             }
+            bottom--;
+            x++;
         }
-        return matrix;
+        return grid;
     }
 }

src/main/java/g3401_3500/s3447_assign_elements_to_groups_with_constraints/Solution.java

@@ -1,35 +1,34 @@
 package g3401_3500.s3447_assign_elements_to_groups_with_constraints;
 
-// #Medium #2025_02_09_Time_527_ms_(_%)_Space_70.23_MB_(_%)
+// #Medium #Array #Hash_Table #2025_02_11_Time_7_ms_(99.06%)_Space_64.05_MB_(91.85%)
 
-import java.util.HashMap;
-import java.util.Map;
+import java.util.Arrays;
 
 public class Solution {
     public int[] assignElements(int[] groups, int[] elements) {
-        Map<Integer, Integer> elementIndexMap = new HashMap<>();
-        for (int i = 0; i < elements.length; i++) {
-            elementIndexMap.putIfAbsent(elements[i], i);
+        int i;
+        int j;
+        int n = (int) (1e5 + 1);
+        int maxi = 0;
+        for (i = 0; i < groups.length; i++) {
+            maxi = Math.max(maxi, groups[i]);
         }
-        int[] result = new int[groups.length];
-        for (int i = 0; i < groups.length; i++) {
-            result[i] = findSmallestIndex(groups[i], elementIndexMap);
-        }
-        return result;
-    }
-
-    private int findSmallestIndex(int groupSize, Map<Integer, Integer> elementIndexMap) {
-        int minIndex = Integer.MAX_VALUE;
-        for (int i = 1; i * i <= groupSize; i++) {
-            if (groupSize % i == 0) {
-                if (elementIndexMap.containsKey(i)) {
-                    minIndex = Math.min(minIndex, elementIndexMap.get(i));
-                }
-                if (i != groupSize / i && elementIndexMap.containsKey(groupSize / i)) {
-                    minIndex = Math.min(minIndex, elementIndexMap.get(groupSize / i));
+        n = maxi + 1;
+        int[] arr = new int[n];
+        int[] ans = new int[groups.length];
+        Arrays.fill(arr, -1);
+        for (i = 0; i < elements.length; i++) {
+            if (elements[i] < n && arr[elements[i]] == -1) {
+                for (j = elements[i]; j < n; j += elements[i]) {
+                    if (arr[j] == -1) {
+                        arr[j] = i;
+                    }
                 }
             }
         }
-        return minIndex == Integer.MAX_VALUE ? -1 : minIndex;
+        for (i = 0; i < groups.length; i++) {
+            ans[i] = arr[groups[i]];
+        }
+        return ans;
     }
 }

src/main/java/g3401_3500/s3448_count_substrings_divisible_by_last_digit/Solution.java

@@ -1,6 +1,6 @@
 package g3401_3500.s3448_count_substrings_divisible_by_last_digit;
 
-// #Hard #2025_02_09_Time_20_ms_(100.00%)_Space_47.10_MB_(100.00%)
+// #Hard #String #Dynamic_Programming #2025_02_11_Time_23_ms_(83.08%)_Space_46.71_MB_(58.21%)
 
 @SuppressWarnings("java:S107")
 public class Solution {

src/main/java/g3401_3500/s3449_maximize_the_minimum_game_score/Solution.java

@@ -1,42 +1,47 @@
 package g3401_3500.s3449_maximize_the_minimum_game_score;
 
-// #Hard #2025_02_09_Time_278_ms_(100.00%)_Space_54.25_MB_(100.00%)
+// #Hard #Array #Greedy #Binary_Search #2025_02_11_Time_188_ms_(100.00%)_Space_52.73_MB_(92.19%)
 
 public class Solution {
-    public long maxScore(int[] points, int m) {
+    private boolean judge(int[] points, long m, long tgt) {
+        long cur = 0L;
+        long nxt = 0L;
         int n = points.length;
-        if (m < n) {
-            return 0;
-        }
-        long lo = 1;
-        long hi = (long) 1e18;
-        long ans = 0;
-        while (lo <= hi) {
-            long mid = lo + (hi - lo) / 2;
-            long tot = 0;
-            long tr = 0;
-            long skip = 0;
-            for (int i = 0; i < n && tot <= m; i++) {
-                int p = points[i];
-                long need = (mid + p - 1L) / p;
-                if (tr >= need) {
-                    tr = 0;
-                    skip++;
-                } else {
-                    long cur = tr * p;
-                    long ops = (mid - cur + p - 1L) / p;
-                    tot += 2 * ops - 1 + skip;
-                    tr = Math.max(ops - 1, 0);
-                    skip = 0;
+        for (int i = 0; i < n; i++) {
+            if (i == n - 1 && nxt >= tgt) {
+                return true;
+            }
+            m--;
+            cur = nxt + points[i];
+            nxt = 0;
+            if (cur < tgt) {
+                long req = (tgt - cur - 1) / points[i] + 1;
+                if (i < n - 1) {
+                    nxt = points[i + 1] * req;
                 }
+                m -= req * 2;
             }
-            if (tot <= m) {
-                ans = mid;
-                lo = mid + 1;
+            if (m < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public long maxScore(int[] points, int m) {
+        long x = 0L;
+        long y = 10000000L * m;
+        while (x < y - 1) {
+            long mid = (x + y) / 2;
+            if (judge(points, m, mid)) {
+                x = mid;
             } else {
-                hi = mid - 1;
+                y = mid - 1;
             }
         }
-        return ans;
+        while (judge(points, m, x + 1)) {
+            x++;
+        }
+        return x;
     }
 }