Online Election

Online Election - Problem

You are given two integer arrays persons and times. In an election, the ith vote was cast for persons[i] at time times[i].

For each query at a time t, find the person that was leading the election at time t. Votes cast at time t will count towards our query. In the case of a tie, the most recent vote (among tied candidates) wins.

Implement the TopVotedCandidate class:

TopVotedCandidate(int[] persons, int[] times) - Initializes the object with the persons and times arrays.
int q(int t) - Returns the number of the person that was leading the election at time t according to the mentioned rules.

Input & Output

Example 1 — Basic Election Tracking

$ Input: persons = [0,1,1,0,0,1,0], times = [0,5,10,15,20,25,30], queries = [3,12,25,15,24,8]

› Output: [0,1,1,0,0,1]

💡 Note: At time 3: person 0 leads (1-0). At time 12: person 1 leads (2-1). At time 25: person 1 leads (3-3, but person 1 voted most recently). At time 15: person 0 leads (2-2, but person 0 voted most recently at time 15).

Example 2 — Early Query

$ Input: persons = [0,1,1,0], times = [0,5,10,15], queries = [2,8]

› Output: [0,1]

💡 Note: At time 2: only person 0 has voted. At time 8: person 1 leads 2-1.

Example 3 — Tie Breaking

$ Input: persons = [0,1,0,1], times = [0,5,10,15], queries = [10,15]

› Output: [0,1]

💡 Note: At time 10: tie 2-2, person 0 voted most recently at time 10. At time 15: tie 2-2, person 1 voted most recently at time 15.

Constraints

1 ≤ persons.length ≤ 5000
times.length == persons.length
0 ≤ persons[i] ≤ 999
1 ≤ times[i] ≤ 10⁹
times is sorted in a strictly increasing order
1 ≤ queries.length ≤ 10⁴
1 ≤ queries[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 M Microsoft 8

The key insight is to preprocess the election state after each vote, then use binary search for fast query answering. The optimal approach precomputes the leader after each vote (handling tie-breaking by recency), then uses binary search to find the latest vote time ≤ query time. Time: O(N + Q log N), Space: O(N).

Common Approaches

✓ Brute Force Query Processing

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

For each query time t, iterate through all votes that occurred at or before time t, count votes for each person, and determine the leader considering tie-breaking rules.

Precompute Winners + Binary Search

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

During initialization, process votes chronologically to determine the leader after each vote. For queries, use binary search to find the latest vote time ≤ query time and return the precomputed leader.

Brute Force Query Processing — Algorithm Steps

For each query time t
Count votes for each person up to time t
Find person with most votes (most recent vote wins ties)
Return the leader

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Time

Check votes up to time t

Count Votes

Count votes for each person up to t

Find Leader

Return person with most votes (ties broken by recency)

Code -

solution.c — C

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

typedef struct {
    int* persons;
    int* times;
    int* leaders;
    int size;
} TopVotedCandidate;

TopVotedCandidate* topVotedCandidateCreate(int* persons, int personsSize, int* times, int timesSize) {
    TopVotedCandidate* obj = (TopVotedCandidate*)malloc(sizeof(TopVotedCandidate));
    obj->persons = (int*)malloc(personsSize * sizeof(int));
    obj->times = (int*)malloc(timesSize * sizeof(int));
    obj->leaders = (int*)malloc(timesSize * sizeof(int));
    obj->size = personsSize;
    
    memcpy(obj->persons, persons, personsSize * sizeof(int));
    memcpy(obj->times, times, timesSize * sizeof(int));
    
    int voteCount[1000];
    memset(voteCount, 0, sizeof(voteCount));
    
    int currentLeader = -1;
    int maxVotes = 0;
    
    for (int i = 0; i < personsSize; i++) {
        int person = persons[i];
        voteCount[person]++;
        
        if (voteCount[person] > maxVotes || (voteCount[person] == maxVotes && person != currentLeader)) {
            maxVotes = voteCount[person];
            currentLeader = person;
        }
        
        obj->leaders[i] = currentLeader;
    }
    
    return obj;
}

int topVotedCandidateQ(TopVotedCandidate* obj, int t) {
    for (int i = obj->size - 1; i >= 0; i--) {
        if (obj->times[i] <= t) {
            return obj->leaders[i];
        }
    }
    return -1;
}

void topVotedCandidateFree(TopVotedCandidate* obj) {
    free(obj->persons);
    free(obj->times);
    free(obj->leaders);
    free(obj);
}

void skipWhitespace(char** ptr) {
    while (**ptr && isspace(**ptr)) (*ptr)++;
}

int parseInt(char** ptr) {
    skipWhitespace(ptr);
    int sign = 1;
    if (**ptr == '-') {
        sign = -1;
        (*ptr)++;
    }
    int num = 0;
    while (**ptr && isdigit(**ptr)) {
        num = num * 10 + (**ptr - '0');
        (*ptr)++;
    }
    return num * sign;
}

int* parseArray(char* str, int* size) {
    int capacity = 100;
    int* arr = (int*)malloc(capacity * sizeof(int));
    *size = 0;
    
    char* ptr = str;
    skipWhitespace(&ptr);
    
    if (*ptr == '[') ptr++;
    
    while (*ptr != '\0' && *ptr != ']') {
        skipWhitespace(&ptr);
        
        if (isdigit(*ptr) || *ptr == '-') {
            if (*size >= capacity) {
                capacity *= 2;
                arr = (int*)realloc(arr, capacity * sizeof(int));
            }
            
            arr[*size] = parseInt(&ptr);
            (*size)++;
        }
        
        skipWhitespace(&ptr);
        if (*ptr == ',') ptr++;
    }
    
    return arr;
}

int main() {
    char line[100000];
    
    if (fgets(line, sizeof(line), stdin) == NULL) return 0;
    int personsSize;
    int* persons = parseArray(line, &personsSize);
    
    if (fgets(line, sizeof(line), stdin) == NULL) {
        free(persons);
        return 0;
    }
    int timesSize;
    int* times = parseArray(line, &timesSize);
    
    if (fgets(line, sizeof(line), stdin) == NULL) {
        free(persons);
        free(times);
        return 0;
    }
    int queriesSize;
    int* queries = parseArray(line, &queriesSize);
    
    TopVotedCandidate* obj = topVotedCandidateCreate(persons, personsSize, times, timesSize);
    
    printf("[");
    for (int i = 0; i < queriesSize; i++) {
        int result = topVotedCandidateQ(obj, queries[i]);
        printf("%d", result);
        if (i < queriesSize - 1) printf(",");
    }
    printf("]\n");
    
    topVotedCandidateFree(obj);
    free(persons);
    free(times);
    free(queries);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(Q × N)

Q queries, each processes up to N votes

⚡ Linearithmic

Space Complexity

O(P)

Hash map to count votes for P unique persons

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

1.1K 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 Query Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler