Online Majority Element In Subarray

Online Majority Element In Subarray - Problem

Design a data structure that efficiently finds the majority element of a given subarray. The majority element of a subarray is an element that occurs threshold times or more in the subarray.

Implement the MajorityChecker class:

MajorityChecker(int[] arr) - Initializes the instance of the class with the given array arr.
int query(int left, int right, int threshold) - Returns the element in the subarray arr[left...right] that occurs at least threshold times, or -1 if no such element exists.

Input & Output

Example 1 — Basic Majority Check

$ Input: arr = [1,1,2,2,1,1], queries = [[0,5,4],[0,3,3],[2,3,2]]

› Output: [1,-1,2]

💡 Note: Query [0,5,4]: Element 1 appears 4 times in full array (≥4). Query [0,3,3]: No element appears ≥3 times in [1,1,2,2]. Query [2,3,2]: Element 2 appears 2 times in [2,2] (≥2).

Example 2 — No Majority Found

$ Input: arr = [1,2,3,4,5], queries = [[0,4,3]]

› Output: [-1]

💡 Note: In range [0,4], each element [1,2,3,4,5] appears only once, none meet threshold 3.

Example 3 — Small Range

$ Input: arr = [3,3,3], queries = [[0,2,2]]

› Output: [3]

💡 Note: Element 3 appears 3 times in range [0,2], which is ≥ threshold 2.

Constraints

1 ≤ arr.length ≤ 2 × 10⁴
1 ≤ arr[i] ≤ 2 × 10⁴
0 ≤ left ≤ right < arr.length
threshold ≤ right - left + 1
1 ≤ queries ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is that true majority elements are rare, so random sampling can efficiently identify candidates. The optimal approach uses preprocessing with index maps plus randomized sampling for O(N + Q × S × log N) time complexity where S is small constant sample size.

Common Approaches

✓ Brute Force - Count Each Query

⏱️ Time: O(Q × N) Space: O(N)

For every query, scan the entire subarray from left to right, count occurrences of each element using a hash map, then check which elements meet the threshold requirement.

Preprocessing with Index Maps

⏱️ Time: O(N + Q × K × log N) Space: O(N)

Build a map where each element maps to a sorted list of its indices. For queries, use binary search to count occurrences in the given range efficiently.

Random Sampling + Binary Search

⏱️ Time: O(N + Q × S × log N) Space: O(N)

Use randomized sampling to find potential majority elements, then verify each candidate using binary search on precomputed index lists. This approach leverages the fact that true majority elements have high probability of being sampled.

Brute Force - Count Each Query — Algorithm Steps

For each query, create empty frequency map
Iterate through subarray [left, right]
Count occurrences of each element
Find elements with count >= threshold

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Range

Select subarray [left, right]

Count Elements

Count frequency of each element

Check Threshold

Return element with count >= threshold

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int* arr;
    int size;
} MajorityChecker;

MajorityChecker* majorityCheckerCreate(int* arr, int arrSize) {
    MajorityChecker* obj = (MajorityChecker*)malloc(sizeof(MajorityChecker));
    obj->arr = (int*)malloc(arrSize * sizeof(int));
    obj->size = arrSize;
    memcpy(obj->arr, arr, arrSize * sizeof(int));
    return obj;
}

int majorityCheckerQuery(MajorityChecker* obj, int left, int right, int threshold) {
    int maxVal = 0;
    for (int i = left; i <= right; i++) {
        if (obj->arr[i] > maxVal) {
            maxVal = obj->arr[i];
        }
    }
    
    int* count = (int*)calloc(maxVal + 1, sizeof(int));
    
    for (int i = left; i <= right; i++) {
        count[obj->arr[i]]++;
        if (count[obj->arr[i]] >= threshold) {
            int result = obj->arr[i];
            free(count);
            return result;
        }
    }
    
    free(count);
    return -1;
}

void majorityCheckerFree(MajorityChecker* obj) {
    free(obj->arr);
    free(obj);
}

int main() {
    char line[100000];
    
    // Read array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char* start = strchr(line, '[');
    char* end = strrchr(line, ']');
    if (start && end) {
        start++;
        *end = '\0';
        
        int arrSize = 0;
        char* temp = strdup(start);
        char* token = strtok(temp, ",");
        while (token) {
            arrSize++;
            token = strtok(NULL, ",");
        }
        free(temp);
        
        int* arr = (int*)malloc(arrSize * sizeof(int));
        int idx = 0;
        token = strtok(start, ",");
        while (token) {
            arr[idx++] = atoi(token);
            token = strtok(NULL, ",");
        }
        
        MajorityChecker* obj = majorityCheckerCreate(arr, arrSize);
        
        // Read queries
        fgets(line, sizeof(line), stdin);
        line[strcspn(line, "\n")] = 0;
        
        start = strchr(line, '[');
        end = strrchr(line, ']');
        if (start && end) {
            start++;
            *end = '\0';
            
            printf("[");
            int first = 1;
            char* queryStart = start;
            while (*queryStart) {
                if (*queryStart == '[') {
                    int left, right, threshold;
                    sscanf(queryStart, "[%d,%d,%d]", &left, &right, &threshold);
                    int result = majorityCheckerQuery(obj, left, right, threshold);
                    if (!first) printf(",");
                    printf("%d", result);
                    first = 0;
                }
                queryStart++;
            }
            printf("]\n");
        }
        
        majorityCheckerFree(obj);
        free(arr);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(Q × N)

Q queries, each scanning up to N elements in worst case

⚡ Linearithmic

Space Complexity

O(N)

Hash map stores up to N unique elements per query

✓ Linear Space

23.5K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Count Each Query — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler