Improved solutions

Author: javadev

src/main/java/g3401_3500/s3461_check_if_digits_are_equal_in_string_after_operations_i/Solution.java

@@ -1,19 +1,22 @@
 package g3401_3500.s3461_check_if_digits_are_equal_in_string_after_operations_i;
 
-// #Easy #2025_02_23_Time_23_ms_(100.00%)_Space_45.51_MB_(100.00%)
+// #Easy #String #Math #Simulation #Number_Theory #Combinatorics
+// #2025_02_25_Time_2_ms_(96.71%)_Space_42.26_MB_(97.03%)
 
 public class Solution {
     public boolean hasSameDigits(String s) {
-        int n = s.length();
-        while (n > 2) {
-            StringBuilder nstr = new StringBuilder();
-            for (int i = 1; i < n; i++) {
-                int next = ((s.charAt(i) - '0') + (s.charAt(i - 1) - '0')) % 10;
-                nstr.append(next);
+        char[] ch = s.toCharArray();
+        int k = ch.length - 1;
+        while (k != 1) {
+            for (int i = 0; i < k; i++) {
+                int a = (int) ch[i] - 48;
+                int b = (int) ch[i + 1] - 48;
+                int d = (a + b) % 10;
+                char c = (char) (d + '0');
+                ch[i] = c;
             }
-            n--;
-            s = nstr.toString();
+            k--;
         }
-        return s.charAt(0) == s.charAt(1);
+        return ch[0] == ch[1];
     }
 }

src/main/java/g3401_3500/s3462_maximum_sum_with_at_most_k_elements/Solution.java

@@ -1,34 +1,29 @@
 package g3401_3500.s3462_maximum_sum_with_at_most_k_elements;
 
-// #Medium #2025_02_23_Time_278_ms_(_%)_Space_73.54_MB_(_%)
-
-import java.util.Collections;
-import java.util.PriorityQueue;
+// #Medium #Array #Sorting #Greedy #Matrix #Heap_(Priority_Queue)
+// #2025_02_25_Time_62_ms_(99.82%)_Space_78.09_MB_(20.19%)
 
 public class Solution {
     public long maxSum(int[][] grid, int[] limits, int k) {
-        if (grid.length == 0) {
-            return 0;
+        int l = 0;
+        for (int i = 0; i < limits.length; i++) {
+            l += limits[i];
         }
-        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
-        PriorityQueue<Integer> temp;
+        int[] dp = new int[l];
+        int a = 0;
         for (int i = 0; i < grid.length; i++) {
-            temp = new PriorityQueue<>(Collections.reverseOrder());
-            for (int j = 0; j < grid[i].length; j++) {
-                temp.add(grid[i][j]);
-            }
-            int cnt = 0;
-            while (!temp.isEmpty() && cnt < limits[i]) {
-                pq.add(temp.poll());
-                cnt += 1;
+            int lim = limits[i];
+            Arrays.sort(grid[i]);
+            for (int j = grid[i].length - lim; j < grid[i].length; j++) {
+                dp[a] = grid[i][j];
+                a++;
             }
         }
-        long result = 0;
-        long count = 0;
-        while (!pq.isEmpty() && count < k) {
-            result += pq.poll();
-            count += 1;
+        Arrays.sort(dp);
+        long sum = 0L;
+        for (int i = l - 1; i >= l - k; i--) {
+            sum += dp[i];
         }
-        return result;
+        return sum;
     }
 }

src/main/java/g3401_3500/s3463_check_if_digits_are_equal_in_string_after_operations_ii/Solution.java

@@ -1,49 +1,74 @@
 package g3401_3500.s3463_check_if_digits_are_equal_in_string_after_operations_ii;
 
-// #Hard #2025_02_23_Time_103_ms_(100.00%)_Space_45.58_MB_(100.00%)
+// #Hard #String #Math #Number_Theory #Combinatorics
+// #2025_02_25_Time_43_ms_(99.64%)_Space_49.40_MB_(10.02%)
 
 public class Solution {
-    public boolean hasSameDigits(String s) {
-        int n = s.length();
-        int nMunus2 = n - 2;
-        int f0 = 0;
-        int f1 = 0;
-        for (int j = 0; j <= nMunus2; j++) {
-            int c = binomMod10(nMunus2, j);
-            f0 = (f0 + c * (s.charAt(j) - '0')) % 10;
-            f1 = (f1 + c * (s.charAt(j + 1) - '0')) % 10;
+    private int powMod10(int a, int n) {
+        int x = 1;
+        while (n >= 1) {
+            if (n % 2 == 1) {
+                x = (x * a) % 10;
+            }
+            a = (a * a) % 10;
+            n /= 2;
         }
-        return f0 == f1;
+        return x;
     }
 
-    private int binomMod10(int n, int k) {
-        int r2 = binomMod2(n, k);
-        int r5 = binomMod5(n, k);
-        for (int x = 0; x < 10; x++) {
-            if (x % 2 == r2 && x % 5 == r5) {
-                return x;
+    private int[] f(int n) {
+        int[] ns = new int[n + 1];
+        int[] n2 = new int[n + 1];
+        int[] n5 = new int[n + 1];
+        ns[0] = 1;
+        for (int i = 1; i <= n; ++i) {
+            int m = i;
+            n2[i] = n2[i - 1];
+            n5[i] = n5[i - 1];
+            while (m % 2 == 0) {
+                m /= 2;
+                n2[i]++;
+            }
+            while (m % 5 == 0) {
+                m /= 5;
+                n5[i]++;
             }
+            ns[i] = (ns[i - 1] * m) % 10;
         }
-        return 0;
-    }
-
-    private int binomMod2(int n, int k) {
-        return ((n & k) == k) ? 1 : 0;
+        int[] inv = new int[10];
+        for (int i = 1; i < 10; ++i) {
+            for (int j = 0; j < 10; ++j) {
+                if (i * j % 10 == 1) {
+                    inv[i] = j;
+                }
+            }
+        }
+        int[] xs = new int[n + 1];
+        for (int k = 0; k <= n; ++k) {
+            int a = 0;
+            int s2 = n2[n] - n2[n - k] - n2[k];
+            int s5 = n5[n] - n5[n - k] - n5[k];
+            if (s2 == 0 || s5 == 0) {
+                a = (ns[n] * inv[ns[n - k]] * inv[ns[k]] * powMod10(2, s2) * powMod10(5, s5)) % 10;
+            }
+            xs[k] = a;
+        }
+        return xs;
     }
 
-    private int binomMod5(int n, int k) {
-        int[][] t = {{1}, {1, 1}, {1, 2, 1}, {1, 3, 3, 1}, {1, 4, 1, 4, 1}};
-        int res = 1;
-        while (n > 0 || k > 0) {
-            int nd = n % 5;
-            int kd = k % 5;
-            if (kd > nd) {
-                return 0;
-            }
-            res = (res * t[nd][kd]) % 5;
-            n /= 5;
-            k /= 5;
+    public boolean hasSameDigits(String s) {
+        int n = s.length();
+        int[] xs = f(n - 2);
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = (int) (s.charAt(i) - '0');
+        }
+        int num1 = 0;
+        int num2 = 0;
+        for (int i = 0; i < n - 1; i++) {
+            num1 = (num1 + xs[i] * arr[i]) % 10;
+            num2 = (num2 + xs[i] * arr[i + 1]) % 10;
         }
-        return res;
+        return num1 == num2;
     }
 }

src/main/java/g3401_3500/s3464_maximize_the_distance_between_points_on_a_square/Solution.java

@@ -1,101 +1,79 @@
 package g3401_3500.s3464_maximize_the_distance_between_points_on_a_square;
 
-// #Hard #2025_02_23_Time_222_ms_(100.00%)_Space_52.33_MB_(100.00%)
+// #Hard #Array #Greedy #Binary_Search #2025_02_25_Time_18_ms_(98.51%)_Space_49.78_MB_(46.27%)
 
 import java.util.Arrays;
 
 public class Solution {
-    public int maxDistance(int sideLength, int[][] points, int requiredPoints) {
-        long perimeter = 4L * sideLength;
-        int numPoints = points.length;
-        long[] mappedPositions = new long[numPoints];
-        for (int i = 0; i < numPoints; i++) {
-            mappedPositions[i] = mapToPerimeter(sideLength, points[i][0], points[i][1]);
-        }
-        Arrays.sort(mappedPositions);
-        long low = 0;
-        long high = perimeter;
-        while (low < high) {
-            long mid = (low + high + 1) / 2;
-            if (isValidDistance(mid, requiredPoints, mappedPositions, perimeter)) {
-                low = mid;
+    public int maxDistance(int side, int[][] pts, int k) {
+        int n = pts.length;
+        long[] p = new long[n];
+        for (int i = 0; i < n; i++) {
+            int x = pts[i][0];
+            int y = pts[i][1];
+            long c;
+            if (y == 0) {
+                c = x;
+            } else if (x == side) {
+                c = side + y;
+            } else if (y == side) {
+                c = 2L * side + (side - x);
             } else {
-                high = mid - 1;
+                c = 3L * side + (side - y);
             }
+            p[i] = c;
         }
-        return (int) low;
-    }
-
-    private long mapToPerimeter(int sideLength, int x, int y) {
-        if (y == sideLength) {
-            return x;
-        }
-        if (x == sideLength) {
-            return sideLength + (long) (sideLength - y);
-        }
-        if (y == 0) {
-            return 2L * sideLength + (sideLength - x);
+        Arrays.sort(p);
+        long c = 4L * side;
+        int tot = 2 * n;
+        long[] dArr = new long[tot];
+        for (int i = 0; i < n; i++) {
+            dArr[i] = p[i];
+            dArr[i + n] = p[i] + c;
         }
-        return 3L * sideLength + y;
-    }
-
-    private boolean isValidDistance(
-            long minDistance, int requiredPoints, long[] mappedPositions, long perimeter) {
-        int numPoints = mappedPositions.length;
-        long[] extendedPositions = new long[2 * numPoints];
-        for (int i = 0; i < numPoints; i++) {
-            extendedPositions[i] = mappedPositions[i];
-            extendedPositions[i + numPoints] = mappedPositions[i] + perimeter;
-        }
-        for (int i = 0; i < numPoints; i++) {
-            if (canSelectRequiredPoints(
-                    i,
-                    minDistance,
-                    requiredPoints,
-                    mappedPositions,
-                    extendedPositions,
-                    perimeter)) {
-                return true;
+        int lo = 0;
+        int hi = 2 * side;
+        int ans = 0;
+        while (lo <= hi) {
+            int mid = (lo + hi) >>> 1;
+            if (check(mid, dArr, n, k, c)) {
+                ans = mid;
+                lo = mid + 1;
+            } else {
+                hi = mid - 1;
             }
         }
-        return false;
+        return ans;
     }
 
-    private boolean canSelectRequiredPoints(
-            int startIndex,
-            long minDistance,
-            int requiredPoints,
-            long[] mappedPositions,
-            long[] extendedPositions,
-            long perimeter) {
-        int selectedCount = 1;
-        long previousPosition = mappedPositions[startIndex];
-        int currentIndex = startIndex;
-        for (int i = 1; i < requiredPoints; i++) {
-            long targetPosition = previousPosition + minDistance;
-            int left = currentIndex + 1;
-            int right = startIndex + mappedPositions.length;
-            int nextIndex = lowerBound(extendedPositions, left, right, targetPosition);
-            if (nextIndex >= right) {
-                return false;
+    private boolean check(int d, long[] dArr, int n, int k, long c) {
+        int len = dArr.length;
+        int[] nxt = new int[len];
+        int j = 0;
+        for (int i = 0; i < len; i++) {
+            if (j < i + 1) {
+                j = i + 1;
+            }
+            while (j < len && dArr[j] < dArr[i] + d) {
+                j++;
             }
-            selectedCount++;
-            previousPosition = extendedPositions[nextIndex];
-            currentIndex = nextIndex;
+            nxt[i] = (j < len) ? j : -1;
         }
-        return selectedCount == requiredPoints
-                && (previousPosition - mappedPositions[startIndex] <= perimeter - minDistance);
-    }
-
-    private int lowerBound(long[] arr, int left, int right, long target) {
-        while (left < right) {
-            int mid = left + (right - left) / 2;
-            if (arr[mid] >= target) {
-                right = mid;
-            } else {
-                left = mid + 1;
+        for (int i = 0; i < n; i++) {
+            int cnt = 1;
+            int cur = i;
+            while (cnt < k) {
+                int nx = nxt[cur];
+                if (nx == -1 || nx >= i + n) {
+                    break;
+                }
+                cur = nx;
+                cnt++;
+            }
+            if (cnt == k && (dArr[i] + c - dArr[cur]) >= d) {
+                return true;
             }
         }
-        return left;
+        return false;
     }
 }