Improved tasks 3707-3715

Author: javadev

src/main/java/g3701_3800/s3707_equal_score_substrings/Solution.java

@@ -1,6 +1,6 @@
 package g3701_3800.s3707_equal_score_substrings;
 
-// #Easy #Biweekly_Contest_167 #2025_10_12_Time_1_ms_(100.00%)_Space_42.74_MB_(100.00%)
+// #Easy #Biweekly_Contest_167 #2025_10_13_Time_1_ms_(100.00%)_Space_42.24_MB_(96.38%)
 
 public class Solution {
     public boolean scoreBalance(String s) {

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_12_Time_2_ms_(100.00%)_Space_58.15_MB_(100.00%)
+// #Medium #Biweekly_Contest_167 #2025_10_13_Time_1_ms_(100.00%)_Space_58.20_MB_(81.69%)
 
 public class Solution {
     public int longestSubarray(int[] nums) {

src/main/java/g3701_3800/s3709_design_exam_scores_tracker/ExamTracker.java

@@ -1,6 +1,6 @@
 package g3701_3800.s3709_design_exam_scores_tracker;
 
-// #Medium #Biweekly_Contest_167 #2025_10_12_Time_120_ms_(100.00%)_Space_101.08_MB_(100.00%)
+// #Medium #Biweekly_Contest_167 #2025_10_13_Time_114_ms_(100.00%)_Space_101.17_MB_(89.67%)
 
 import java.util.ArrayList;
 import java.util.List;

src/main/java/g3701_3800/s3710_maximum_partition_factor/Solution.java

@@ -1,6 +1,6 @@
 package g3701_3800.s3710_maximum_partition_factor;
 
-// #Hard #Biweekly_Contest_167 #2025_10_12_Time_304_ms_(50.00%)_Space_55.99_MB_(50.00%)
+// #Hard #Biweekly_Contest_167 #2025_10_13_Time_305_ms_(50.00%)_Space_55.41_MB_(49.74%)
 
 import java.util.ArrayList;
 import java.util.Comparator;

src/main/java/g3701_3800/s3712_sum_of_elements_with_frequency_divisible_by_k/Solution.java

@@ -1,22 +1,23 @@
 package g3701_3800.s3712_sum_of_elements_with_frequency_divisible_by_k;
 
-// #Easy #Weekly_Contest_471 #2025_10_12_Time_3_ms_(_%)_Space_43.23_MB_(_%)
-
-import java.util.HashMap;
-import java.util.Map;
+// #Easy #Weekly_Contest_471 #2025_10_13_Time_1_ms_(99.96%)_Space_42.21_MB_(100.00%)
 
 public class Solution {
     public int sumDivisibleByK(int[] nums, int k) {
-        Map<Integer, Integer> mp = new HashMap<>();
-        for (int i : nums) {
-            mp.put(i, mp.getOrDefault(i, 0) + 1);
+        int max = 0;
+        int sum = 0;
+        for (int num : nums) {
+            max = Math.max(num, max);
+        }
+        int[] cnt = new int[max + 1];
+        for (int num : nums) {
+            cnt[num]++;
         }
-        int ans = 0;
-        for (Map.Entry<Integer, Integer> e : mp.entrySet()) {
-            if (e.getValue() % k == 0) {
-                ans += e.getKey() * e.getValue();
+        for (int i = 1; i < cnt.length; i++) {
+            if (cnt[i] != 0 && cnt[i] % k == 0) {
+                sum += i * cnt[i];
             }
         }
-        return ans;
+        return sum;
     }
 }

src/main/java/g3701_3800/s3713_longest_balanced_substring_i/Solution.java

@@ -1,6 +1,6 @@
 package g3701_3800.s3713_longest_balanced_substring_i;
 
-// #Medium #Weekly_Contest_471 #2025_10_12_Time_32_ms_(100.00%)_Space_45.70_MB_(50.00%)
+// #Medium #Weekly_Contest_471 #2025_10_13_Time_34_ms_(99.73%)_Space_45.52_MB_(50.00%)
 
 public class Solution {
     public int longestBalanced(String s) {

src/main/java/g3701_3800/s3714_longest_balanced_substring_ii/Solution.java

@@ -1,59 +1,92 @@
 package g3701_3800.s3714_longest_balanced_substring_ii;
 
-// #Medium #Weekly_Contest_471 #2025_10_12_Time_788_ms_(_%)_Space_144.17_MB_(_%)
+// #Medium #Weekly_Contest_471 #2025_10_13_Time_196_ms_(98.70%)_Space_60.59_MB_(100.00%)
 
 import java.util.HashMap;
-import java.util.Map;
 
-@SuppressWarnings("unchecked")
 public class Solution {
-    private int n;
-
-    // key function: converts 3 counts into a unique number
-    private long key(long[] cnt) {
-        return cnt[0] + cnt[1] * (n + 1L) + cnt[2] * (n + 1L) * (n + 1L);
-    }
-
     public int longestBalanced(String s) {
-        n = s.length();
-        // counts of 'a','b','c'
-        long[] cnt = new long[3];
-        long[] cur = new long[3];
-        int ans = 0;
-        // create 8 maps for all subsets
-        Map<Long, Integer>[] mp = new HashMap[8];
-        for (int j = 0; j < 8; j++) {
-            mp[j] = new HashMap<>();
-            // initialize with 0 -> -1
-            mp[j].put(0L, -1);
+        int n = s.length();
+        int max1 = 1;
+        int curr = 1;
+        for (int i = 1; i < n; i++) {
+            if (s.charAt(i) == s.charAt(i - 1)) {
+                curr++;
+            } else {
+                max1 = Math.max(max1, curr);
+                curr = 1;
+            }
         }
-        for (int i = 0; i < n; i++) {
-            int x = s.charAt(i) - 'a';
-            cnt[x]++;
-            // iterate over all non-empty subsets (1..7)
-            for (int m = 7; m > 0; m--) {
-                long mind = n;
-                for (int b = 0; b < 3; b++) {
-                    int bit = 1 << b;
-                    if ((bit & m) != 0) {
-                        mind = Math.min(mind, cnt[b]);
-                    }
-                    cur[b] = cnt[b];
+        max1 = Math.max(max1, curr);
+        int max2 = 0;
+        char[] chars = {'a', 'b', 'c'};
+        for (int p = 0; p < 3; p++) {
+            char x = chars[p];
+            char y = chars[(p + 1) % 3];
+            char z = chars[(p + 2) % 3];
+            int ii = 0;
+            while (ii < n) {
+                if (s.charAt(ii) == z) {
+                    ii++;
+                    continue;
                 }
-                for (int b = 0; b < 3; b++) {
-                    int bit = 1 << b;
-                    if ((bit & m) != 0) {
-                        cur[b] -= mind;
-                    }
+                int start = ii;
+                while (ii < n && s.charAt(ii) != z) {
+                    ii++;
+                }
+                int endd = ii;
+                int lenSeg = endd - start;
+                if (lenSeg < 2) {
+                    continue;
                 }
-                long k = key(cur);
-                if (mp[m].containsKey(k)) {
-                    ans = Math.max(ans, i - mp[m].get(k));
-                } else {
-                    mp[m].put(k, i);
+                HashMap<Integer, Integer> map2 = new HashMap<>();
+                int diff = 0;
+                map2.put(0, 0);
+                for (int j = start; j < endd; j++) {
+                    char ch = s.charAt(j);
+                    if (ch == x) {
+                        diff += 1;
+                    } else if (ch == y) {
+                        diff -= 1;
+                    }
+                    int localPos = j - start + 1;
+                    Integer prevv = map2.get(diff);
+                    if (prevv != null) {
+                        max2 = Math.max(max2, localPos - prevv);
+                    }
+                    if (!map2.containsKey(diff)) {
+                        map2.put(diff, localPos);
+                    }
                 }
             }
         }
-        return ans;
+        int max3 = 0;
+        HashMap<Long, Integer> map3 = new HashMap<>();
+        int d1 = 0;
+        int d2 = 0;
+        long offset = 100001L;
+        long mult = 200003L;
+        long keyy = (d1 + offset) * mult + (d2 + offset);
+        map3.put(keyy, 0);
+        for (int i = 1; i <= n; i++) {
+            char ch = s.charAt(i - 1);
+            if (ch == 'a') {
+                d1 += 1;
+                d2 += 1;
+            } else if (ch == 'b') {
+                d1 -= 1;
+            } else if (ch == 'c') {
+                d2 -= 1;
+            }
+            keyy = (d1 + offset) * mult + (d2 + offset);
+            Integer prev = map3.get(keyy);
+            if (prev != null) {
+                max3 = Math.max(max3, i - prev);
+            }
+            if (!map3.containsKey(keyy)) {
+                map3.put(keyy, i);
+            }
+        }
+        return Math.max(max1, Math.max(max2, max3));
     }
 }

src/main/java/g3701_3800/s3715_sum_of_perfect_square_ancestors/Solution.java

@@ -1,65 +1,83 @@
 package g3701_3800.s3715_sum_of_perfect_square_ancestors;
 
-// #Hard #Weekly_Contest_471 #2025_10_12_Time_234_ms_(100.00%)_Space_113.24_MB_(100.00%)
+// #Hard #Weekly_Contest_471 #2025_10_13_Time_134_ms_(95.90%)_Space_122.89_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 int MAX = 100000;
+    // smallest prime factor
+    private static final int[] SPF = new int[MAX + 1];
+
+    // Precompute smallest prime factors for fast factorization
+    static {
+        for (int i = 2; i <= MAX; i++) {
+            if (SPF[i] == 0) {
+                for (int j = i; j <= MAX; j += i) {
+                    if (SPF[j] == 0) {
+                        SPF[j] = i;
+                    }
+                }
+            }
+        }
+    }
+
     public long sumOfAncestors(int n, int[][] edges, int[] nums) {
-        List<List<Integer>> g = new ArrayList<>();
+        // Build adjacency list
+        List<List<Integer>> adj = new ArrayList<>();
         for (int i = 0; i < n; i++) {
-            g.add(new ArrayList<>());
+            adj.add(new ArrayList<>());
         }
         for (int[] e : edges) {
-            g.get(e[0]).add(e[1]);
-            g.get(e[1]).add(e[0]);
-        }
-        long[] k = new long[n];
-        for (int i = 0; i < n; i++) {
-            k[i] = kernel(nums[i]);
+            adj.get(e[0]).add(e[1]);
+            adj.get(e[1]).add(e[0]);
         }
-        Map<Long, Integer> freq = new HashMap<>();
-        long[] ans = new long[1];
-        dfs(0, -1, g, k, freq, ans);
-        return ans[0];
+        // Map to count kernel frequencies along DFS path
+        // kernel fits in int (<= nums[i])
+        Map<Integer, Integer> freq = new HashMap<>();
+        long total = 0L;
+        total += dfs(0, -1, adj, nums, freq);
+        return total;
     }
 
-    private long kernel(long x) {
-        long res = 1;
-        for (long p = 2; p * p <= x; p++) {
-            int odd = 0;
-            while (x % p == 0) {
-                x /= p;
-                odd ^= 1;
-            }
-            if (odd == 1) {
-                res *= p;
+    private long dfs(
+            int node, int parent, List<List<Integer>> adj, int[] nums, Map<Integer, Integer> freq) {
+        // kernel <= nums[node] <= 1e5 fits int
+        int key = (int) getKernel(nums[node]);
+        int count = freq.getOrDefault(key, 0);
+        long sum = count;
+        freq.put(key, count + 1);
+        for (int nei : adj.get(node)) {
+            if (nei != parent) {
+                sum += dfs(nei, node, adj, nums, freq);
             }
         }
-        if (x > 1) {
-            res *= x;
+        if (count == 0) {
+            freq.remove(key);
+        } else {
+            freq.put(key, count);
         }
-        return res;
+        return sum;
     }
 
-    private void dfs(
-            int u, int p, List<List<Integer>> g, long[] k, Map<Long, Integer> freq, long[] ans) {
-        long ku = k[u];
-        ans[0] += freq.getOrDefault(ku, 0);
-        freq.put(ku, freq.getOrDefault(ku, 0) + 1);
-        for (int v : g.get(u)) {
-            if (v != p) {
-                dfs(v, u, g, k, freq, ans);
+    // Compute square-free kernel using prime factorization parity
+    private long getKernel(int x) {
+        long key = 1;
+        while (x > 1) {
+            int p = SPF[x];
+            int c = 0;
+            while (x % p == 0) {
+                x /= p;
+                // toggle parity
+                c ^= 1;
+            }
+            if (c == 1) {
+                key *= p;
             }
         }
-        int left = freq.get(ku) - 1;
-        if (left == 0) {
-            freq.remove(ku);
-        } else {
-            freq.put(ku, left);
-        }
+        return key;
     }
 }