Improved task 3636

Author: javadev

src/main/java/g3601_3700/s3636_threshold_majority_queries/Solution.java

@@ -1,133 +1,103 @@
 package g3601_3700.s3636_threshold_majority_queries;
 
-// #Hard #Biweekly_Contest_162 #2025_08_03_Time_1027_ms_(_%)_Space_72.53_MB_(100.00%)
+// #Hard #Biweekly_Contest_162 #2025_08_06_Time_82_ms_(98.38%)_Space_71.28_MB_(74.76%)
 
 import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
-import java.util.TreeSet;
 
-@SuppressWarnings("java:S1210")
 public class Solution {
+    private int[] nums;
+    private int[] indexToValue;
+    private int[] cnt;
+    private int maxCnt = 0;
+    private int minVal = 0;
 
-    private static class FreqPair implements Comparable<FreqPair> {
-        int count;
-        int value;
-
-        public FreqPair(int count, int value) {
-            this.count = count;
-            this.value = value;
-        }
-
-        @Override
-        public int compareTo(FreqPair other) {
-            if (this.count != other.count) {
-                return Integer.compare(this.count, other.count);
-            }
-            return Integer.compare(other.value, this.value);
-        }
-    }
-
-    // A helper class to store a query's range and its original index.
     private static class Query {
+        int bid;
         int l;
         int r;
-        int originalIndex;
+        int threshold;
+        int qid;
 
-        public Query(int l, int r, int idx) {
+        Query(int bid, int l, int r, int threshold, int qid) {
+            this.bid = bid;
             this.l = l;
             this.r = r;
-            this.originalIndex = idx;
-        }
-    }
-
-    private int[] nums;
-    private Map<Integer, Integer> counts;
-    private TreeSet<FreqPair> sortedFrequencies;
-
-    private void add(int pos) {
-        int val = this.nums[pos];
-        int oldCount = this.counts.getOrDefault(val, 0);
-        if (oldCount > 0) {
-            this.sortedFrequencies.remove(new FreqPair(oldCount, val));
-        }
-        int newCount = oldCount + 1;
-        this.counts.put(val, newCount);
-        this.sortedFrequencies.add(new FreqPair(newCount, val));
-    }
-
-    private void remove(int pos) {
-        int val = this.nums[pos];
-        int oldCount = this.counts.get(val);
-        this.sortedFrequencies.remove(new FreqPair(oldCount, val));
-        int newCount = oldCount - 1;
-        if (newCount > 0) {
-            this.counts.put(val, newCount);
-            this.sortedFrequencies.add(new FreqPair(newCount, val));
-        } else {
-            this.counts.remove(val);
+            this.threshold = threshold;
+            this.qid = qid;
         }
     }
 
     public int[] subarrayMajority(int[] nums, int[][] queries) {
-        this.nums = nums;
-        this.counts = new HashMap<>();
-        this.sortedFrequencies = new TreeSet<>();
         int n = nums.length;
-        int qLen = queries.length;
-        List<Query> queryList = new ArrayList<>();
-        int[] thresholds = new int[qLen];
-        for (int i = 0; i < qLen; i++) {
-            queryList.add(new Query(queries[i][0], queries[i][1], i));
-            thresholds[i] = queries[i][2];
-        }
-        int blockSize = 1;
-        if (qLen > 0) {
-            blockSize = Math.max(1, (int) (n / Math.sqrt(qLen)));
+        int m = queries.length;
+        this.nums = nums;
+        cnt = new int[n + 1];
+        int[] nums2 = nums.clone();
+        Arrays.sort(nums2);
+        indexToValue = new int[n];
+        for (int i = 0; i < n; i++) {
+            indexToValue[i] = Arrays.binarySearch(nums2, nums[i]);
         }
-        final int finalBlockSize = blockSize;
-        queryList.sort(
-                (a, b) -> {
-                    int blockA = a.l / finalBlockSize;
-                    int blockB = b.l / finalBlockSize;
-                    if (blockA != blockB) {
-                        return Integer.compare(blockA, blockB);
-                    }
-                    if ((blockA % 2) == 1) {
-                        return Integer.compare(b.r, a.r);
-                    } else {
-                        return Integer.compare(a.r, b.r);
-                    }
-                });
-
-        int[] ans = new int[qLen];
-        int currentL = 0;
-        int currentR = -1;
-        for (Query q : queryList) {
-            while (currentL > q.l) {
-                add(--currentL);
+        int[] ans = new int[m];
+        int blockSize = (int) Math.ceil(n / Math.sqrt(m));
+        List<Query> qs = new ArrayList<>();
+        for (int i = 0; i < m; i++) {
+            int[] q = queries[i];
+            int l = q[0];
+            int r = q[1] + 1;
+            int threshold = q[2];
+            if (r - l > blockSize) {
+                qs.add(new Query(l / blockSize, l, r, threshold, i));
+                continue;
             }
-            while (currentR < q.r) {
-                add(++currentR);
+            for (int j = l; j < r; j++) {
+                add(j);
             }
-            while (currentL < q.l) {
-                remove(currentL++);
+            ans[i] = maxCnt >= threshold ? minVal : -1;
+            for (int j = l; j < r; j++) {
+                cnt[indexToValue[j]]--;
             }
-            while (currentR > q.r) {
-                remove(currentR--);
+            maxCnt = 0;
+        }
+        qs.sort((a, b) -> a.bid != b.bid ? a.bid - b.bid : a.r - b.r);
+        int r = 0;
+        for (int i = 0; i < qs.size(); i++) {
+            Query q = qs.get(i);
+            int l0 = (q.bid + 1) * blockSize;
+            if (i == 0 || q.bid > qs.get(i - 1).bid) {
+                r = l0;
+                Arrays.fill(cnt, 0);
+                maxCnt = 0;
+            }
+            for (; r < q.r; r++) {
+                add(r);
+            }
+            int tmpMaxCnt = maxCnt;
+            int tmpMinVal = minVal;
+            for (int j = q.l; j < l0; j++) {
+                add(j);
             }
-            if (sortedFrequencies.isEmpty()) {
-                ans[q.originalIndex] = -1;
-            } else {
-                FreqPair mostFrequent = sortedFrequencies.last();
-                if (mostFrequent.count >= thresholds[q.originalIndex]) {
-                    ans[q.originalIndex] = mostFrequent.value;
-                } else {
-                    ans[q.originalIndex] = -1;
-                }
+            ans[q.qid] = maxCnt >= q.threshold ? minVal : -1;
+            maxCnt = tmpMaxCnt;
+            minVal = tmpMinVal;
+            for (int j = q.l; j < l0; j++) {
+                cnt[indexToValue[j]]--;
             }
         }
         return ans;
     }
+
+    private void add(int i) {
+        int v = indexToValue[i];
+        int c = ++cnt[v];
+        int x = nums[i];
+        if (c > maxCnt) {
+            maxCnt = c;
+            minVal = x;
+        } else if (c == maxCnt) {
+            minVal = Math.min(minVal, x);
+        }
+    }
 }