Updated tags

javadev · javadev · commit 3973ef67040d · 2025-10-14T08:50:04.000+03:00
diff --git a/src/main/java/g3701_3800/s3707_equal_score_substrings/Solution.java b/src/main/java/g3701_3800/s3707_equal_score_substrings/Solution.java
@@ -1,6 +1,7 @@
 package g3701_3800.s3707_equal_score_substrings;
 
-// #Easy #Biweekly_Contest_167 #2025_10_13_Time_1_ms_(100.00%)_Space_42.24_MB_(96.38%)
+// #Easy #String #Prefix_Sum #Biweekly_Contest_167
+// #2025_10_14_Time_1_ms_(100.00%)_Space_42.65_MB_(41.05%)
 
 public class Solution {
     public boolean scoreBalance(String s) {
diff --git a/src/main/java/g3701_3800/s3708_longest_fibonacci_subarray/Solution.java b/src/main/java/g3701_3800/s3708_longest_fibonacci_subarray/Solution.java
@@ -1,6 +1,6 @@
 package g3701_3800.s3708_longest_fibonacci_subarray;
 
-// #Medium #Biweekly_Contest_167 #2025_10_13_Time_1_ms_(100.00%)_Space_58.20_MB_(81.69%)
+// #Medium #Array #Biweekly_Contest_167 #2025_10_14_Time_1_ms_(100.00%)_Space_58.41_MB_(37.64%)
 
 public class Solution {
     public int longestSubarray(int[] nums) {
diff --git a/src/main/java/g3701_3800/s3709_design_exam_scores_tracker/ExamTracker.java b/src/main/java/g3701_3800/s3709_design_exam_scores_tracker/ExamTracker.java
@@ -1,74 +1,69 @@
 package g3701_3800.s3709_design_exam_scores_tracker;
 
-// #Medium #Biweekly_Contest_167 #2025_10_13_Time_114_ms_(100.00%)_Space_101.17_MB_(89.67%)
+// #Medium #Array #Binary_Search #Design #Prefix_Sum #Biweekly_Contest_167
+// #2025_10_14_Time_102_ms_(99.55%)_Space_101.26_MB_(83.89%)
 
 import java.util.ArrayList;
-import java.util.List;
 
 @SuppressWarnings("java:S6213")
 public class ExamTracker {
-    List<Integer> arr = new ArrayList<>();
-    List<Long> psum = new ArrayList<>();
+
+    private final ArrayList<Integer> ti;
+    private final ArrayList<Long> pr;
+
+    public ExamTracker() {
+        ti = new ArrayList<>();
+        pr = new ArrayList<>();
+    }
 
     public void record(int time, int score) {
-        arr.add(time);
-        if (psum.isEmpty()) {
-            psum.add((long) score);
-        } else {
-            psum.add(psum.get(psum.size() - 1) + score);
-        }
+        ti.add(time);
+        long pv = pr.isEmpty() ? 0L : pr.get(pr.size() - 1);
+        pr.add(pv + (long) score);
     }
 
     public long totalScore(int startTime, int endTime) {
-        int start = bs(startTime);
-        int end = be(endTime);
-
-        if (start > end || start == arr.size() || end == -1) {
-            return 0;
+        int n = ti.size();
+        if (n == 0) {
+            return 0L;
         }
-
-        long total = 0;
-        total += psum.get(end);
-        if (start - 1 >= 0) {
-            total -= psum.get(start - 1);
+        int l = lB(startTime);
+        int rE = fGt(endTime);
+        int r = rE - 1;
+        if (l > r) {
+            return 0L;
         }
-        return total;
+        long sR = pr.get(r);
+        long sL = (l > 0) ? pr.get(l - 1) : 0L;
+        return sR - sL;
     }
 
-    public int bs(int startTime) {
-        int low = 0;
-        int high = arr.size() - 1;
-
-        int ans = arr.size();
-        while (low <= high) {
-            int mid = (low + high) / 2;
-            if (arr.get(mid) >= startTime) {
-                ans = mid;
-                high = mid - 1;
+    private int lB(int t) {
+        int l = 0;
+        int r = ti.size();
+        while (l < r) {
+            int m = (l + r) >>> 1;
+            if (ti.get(m) < t) {
+                l = m + 1;
             } else {
-                low = mid + 1;
+                r = m;
             }
         }
-
-        return ans;
+        return l;
     }
 
-    public int be(int endTime) {
-        int low = 0;
-        int high = arr.size() - 1;
-
-        int ans = -1;
-        while (low <= high) {
-            int mid = (low + high) / 2;
-            if (arr.get(mid) <= endTime) {
-                ans = mid;
-                low = mid + 1;
+    private int fGt(int t) {
+        int l = 0;
+        int r = ti.size();
+        while (l < r) {
+            int m = (l + r) >>> 1;
+            if (ti.get(m) <= t) {
+                l = m + 1;
             } else {
-                high = mid - 1;
+                r = m;
             }
         }
-
-        return ans;
+        return l;
     }
 }
 
diff --git a/src/main/java/g3701_3800/s3710_maximum_partition_factor/Solution.java b/src/main/java/g3701_3800/s3710_maximum_partition_factor/Solution.java
@@ -1,76 +1,70 @@
 package g3701_3800.s3710_maximum_partition_factor;
 
-// #Hard #Biweekly_Contest_167 #2025_10_13_Time_305_ms_(50.00%)_Space_55.41_MB_(49.74%)
+// #Hard #Array #Binary_Search #Graph #Union_Find #Biweekly_Contest_167 #Depth_First_Search
+// #Breadth_First_Search #2025_10_14_Time_46_ms_(99.31%)_Space_45.31_MB_(84.72%)
 
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.Arrays;
 
 public class Solution {
-    public int maxPartitionFactor(int[][] arr) {
-        int n = arr.length;
+    public int maxPartitionFactor(int[][] points) {
+        int n = points.length;
         if (n == 2) {
             return 0;
         }
-        // Step 1: Create list of (distance, i, j)
-        List<int[]> edges = new ArrayList<>();
+        int[][] dist = new int[n][n];
+        int maxDist = 0;
         for (int i = 0; i < n; i++) {
             for (int j = i + 1; j < n; j++) {
-                int d = Math.abs(arr[i][0] - arr[j][0]) + Math.abs(arr[i][1] - arr[j][1]);
-                edges.add(new int[] {d, i, j});
+                int d =
+                        Math.abs(points[i][0] - points[j][0])
+                                + Math.abs(points[i][1] - points[j][1]);
+                dist[i][j] = dist[j][i] = d;
+                if (d > maxDist) {
+                    maxDist = d;
+                }
             }
         }
-        // Step 2: Sort by distance
-        edges.sort(Comparator.comparingInt(a -> a[0]));
-        // Step 3: Union-Find setup
-        int[] parent = new int[n];
-        int[] weight = new int[n];
-        for (int i = 0; i < n; i++) {
-            parent[i] = i;
-            weight[i] = 1;
-        }
-        Map<Integer, Integer> opp = new HashMap<>();
-        // Step 4: Process edges
-        for (int[] e : edges) {
-            int d = e[0];
-            int i = e[1];
-            int j = e[2];
-            if (find(i, parent) == find(j, parent)) {
-                return d;
-            }
-            if (opp.containsKey(i)) {
-                union(opp.get(i), j, parent, weight);
+        int low = 0;
+        int high = maxDist;
+        while (low < high) {
+            int mid = low + (high - low + 1) / 2;
+            if (isFeasible(dist, mid)) {
+                low = mid;
+            } else {
+                high = mid - 1;
             }
-            if (opp.containsKey(j)) {
-                union(opp.get(j), i, parent, weight);
-            }
-            opp.put(i, j);
-            opp.put(j, i);
         }
-        return edges.get(edges.size() - 1)[0];
+        return low;
     }
 
-    private int find(int a, int[] parent) {
-        if (parent[a] != a) {
-            parent[a] = find(parent[a], parent);
-        }
-        return parent[a];
-    }
-
-    private void union(int x, int y, int[] parent, int[] weight) {
-        x = find(x, parent);
-        y = find(y, parent);
-        if (x == y) {
-            return;
-        }
-        if (weight[x] < weight[y]) {
-            int temp = x;
-            x = y;
-            y = temp;
+    private boolean isFeasible(int[][] dist, int t) {
+        int n = dist.length;
+        int[] color = new int[n];
+        Arrays.fill(color, -1);
+        int[] queue = new int[n];
+        for (int i = 0; i < n; i++) {
+            if (color[i] != -1) {
+                continue;
+            }
+            int head = 0;
+            int tail = 0;
+            queue[tail++] = i;
+            color[i] = 0;
+            while (head < tail) {
+                int u = queue[head++];
+                for (int v = 0; v < n; v++) {
+                    if (u == v || dist[u][v] >= t) {
+                        continue;
+                    }
+                    if (color[v] == -1) {
+                        color[v] = color[u] ^ 1;
+                        queue[tail++] = v;
+                    } else if (color[v] == color[u]) {
+                        return false;
+                    }
+                }
+            }
         }
-        weight[y] += weight[x];
-        parent[x] = y;
+        return true;
     }
 }
diff --git a/src/main/java/g3701_3800/s3712_sum_of_elements_with_frequency_divisible_by_k/Solution.java b/src/main/java/g3701_3800/s3712_sum_of_elements_with_frequency_divisible_by_k/Solution.java
@@ -1,6 +1,7 @@
 package g3701_3800.s3712_sum_of_elements_with_frequency_divisible_by_k;
 
-// #Easy #Weekly_Contest_471 #2025_10_13_Time_1_ms_(99.96%)_Space_42.21_MB_(100.00%)
+// #Easy #Array #Hash_Table #Counting #Weekly_Contest_471
+// #2025_10_14_Time_1_ms_(99.96%)_Space_42.30_MB_(98.20%)
 
 public class Solution {
     public int sumDivisibleByK(int[] nums, int k) {
diff --git a/src/main/java/g3701_3800/s3713_longest_balanced_substring_i/Solution.java b/src/main/java/g3701_3800/s3713_longest_balanced_substring_i/Solution.java
@@ -1,6 +1,7 @@
 package g3701_3800.s3713_longest_balanced_substring_i;
 
-// #Medium #Weekly_Contest_471 #2025_10_13_Time_34_ms_(99.73%)_Space_45.52_MB_(50.00%)
+// #Medium #String #Hash_Table #Counting #Enumeration #Weekly_Contest_471
+// #2025_10_14_Time_32_ms_(99.85%)_Space_45.25_MB_(91.33%)
 
 public class Solution {
     public int longestBalanced(String s) {
diff --git a/src/main/java/g3701_3800/s3714_longest_balanced_substring_ii/Solution.java b/src/main/java/g3701_3800/s3714_longest_balanced_substring_ii/Solution.java
diff --git a/src/main/java/g3701_3800/s3715_sum_of_perfect_square_ancestors/Solution.java b/src/main/java/g3701_3800/s3715_sum_of_perfect_square_ancestors/Solution.java
