Event Scheduler - Problem

Design an Event Scheduler system that manages events by priority and time. The system should be able to:

Schedule new events with a given priority, start time, and duration
Detect and handle scheduling conflicts
Retrieve the next event to be executed
Cancel existing events

Implement the EventScheduler class with the following methods:

schedule(eventId, priority, startTime, duration) - Schedule a new event
getNextEvent() - Get the event with highest priority that should run next
hasConflict(startTime, duration) - Check if a time slot conflicts with existing events
cancel(eventId) - Remove an event from the schedule

Events with higher priority values should be executed first. If priorities are equal, earlier start times take precedence.

Input & Output

Example 1 — Basic Scheduling Operations

$ Input: operations = [["schedule","E1",5,10,3],["schedule","E2",8,5,2],["getNextEvent"],["hasConflict",6,2],["cancel","E2"]]

› Output: ["SCHEDULED","SCHEDULED","E2",true,"CANCELLED"]

💡 Note: Schedule E1 (priority 5, time 10-13) succeeds. Schedule E2 (priority 8, time 5-7) succeeds. Next event is E2 (higher priority 8). Time 6-8 conflicts with E2 (5-7). Cancel E2 succeeds.

Example 2 — Conflict Detection

$ Input: operations = [["schedule","A",3,15,5],["schedule","B",7,17,4],["hasConflict",14,3],["getNextEvent"]]

› Output: ["SCHEDULED","CONFLICT",true,"A"]

💡 Note: Schedule A (15-20) succeeds. Schedule B (17-21) conflicts with A at time 17-19. Check 14-17 conflicts with A at time 15-16. Next event is A (only active event).

Example 3 — Priority Ordering

$ Input: operations = [["schedule","LOW",2,20,2],["schedule","HIGH",9,25,1],["schedule","MID",5,30,3],["getNextEvent"]]

› Output: ["SCHEDULED","SCHEDULED","SCHEDULED","HIGH"]

💡 Note: Schedule three events with different priorities (2, 9, 5). GetNextEvent returns HIGH because it has the highest priority (9).

Constraints

1 ≤ operations.length ≤ 1000
Event IDs are unique strings with length ≤ 10
1 ≤ priority ≤ 100
0 ≤ startTime ≤ 10⁶
1 ≤ duration ≤ 1000

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 A Apple 28

The key insight is to balance priority-based scheduling with efficient conflict detection using appropriate data structures. The optimal approach uses TreeMap/sorted structures for O(log n) operations on both priority ordering and time-based conflict checking. Time: O(log n) per operation, Space: O(n)

Common Approaches

✓ Balanced Approach with Sorted Structures

⏱️ Time: O(log n) Space: O(n)

Maintain events in multiple sorted data structures: priority-ordered for retrieval and time-ordered for conflict detection. This provides balanced performance across all operations.

Brute Force with Linear Search

⏱️ Time: O(n²) Space: O(n)

Store all events in a simple array and perform linear searches for scheduling, conflict detection, and retrieval. Sort the entire array each time we need to find the next event.

Priority Queue with Heap

⏱️ Time: O(n log n) Space: O(n)

Maintain events in a max-heap ordered by priority and start time. Use separate interval checking for conflict detection. This provides efficient priority-based retrieval.

Balanced Approach with Sorted Structures — Algorithm Steps

Use TreeMap to maintain events sorted by priority and time
Use separate interval tree or sorted list for conflict detection
Binary search for conflict detection in O(log n)
Direct access to highest priority event

Visualization

Tap to expand

Step-by-Step Walkthrough

Priority Tree

TreeMap sorted by priority for O(log n) retrieval

Time Tree

Separate structure for O(log n) conflict detection

Balanced Ops

All operations run in O(log n) time

Code -

solution.c — C

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

#define MAX_EVENTS 1000
#define MAX_ID_LEN 50

typedef struct {
    char eventId[MAX_ID_LEN];
    int priority;
    int startTime;
    int duration;
    int endTime;
    int active;
} Event;

typedef struct {
    Event events[MAX_EVENTS];
    int count;
} EventScheduler;

EventScheduler* createScheduler() {
    EventScheduler* scheduler = (EventScheduler*)malloc(sizeof(EventScheduler));
    scheduler->count = 0;
    return scheduler;
}

int hasConflict(EventScheduler* scheduler, int startTime, int duration) {
    int endTime = startTime + duration;
    for (int i = 0; i < scheduler->count; i++) {
        Event* event = &scheduler->events[i];
        if (event->active && !(endTime <= event->startTime || startTime >= event->endTime)) {
            return 1;
        }
    }
    return 0;
}

char* schedule(EventScheduler* scheduler, char* eventId, int priority, int startTime, int duration) {
    if (hasConflict(scheduler, startTime, duration)) {
        return "CONFLICT";
    }
    Event* event = &scheduler->events[scheduler->count];
    strcpy(event->eventId, eventId);
    event->priority = priority;
    event->startTime = startTime;
    event->duration = duration;
    event->endTime = startTime + duration;
    event->active = 1;
    scheduler->count++;
    return "SCHEDULED";
}

int compareEvents(const void* a, const void* b) {
    Event* ea = (Event*)a;
    Event* eb = (Event*)b;
    if (ea->priority != eb->priority) {
        return eb->priority - ea->priority;
    }
    return ea->startTime - eb->startTime;
}

char* getNextEvent(EventScheduler* scheduler) {
    Event activeEvents[MAX_EVENTS];
    int activeCount = 0;
    
    for (int i = 0; i < scheduler->count; i++) {
        if (scheduler->events[i].active) {
            activeEvents[activeCount++] = scheduler->events[i];
        }
    }
    
    if (activeCount == 0) {
        return "NONE";
    }
    
    qsort(activeEvents, activeCount, sizeof(Event), compareEvents);
    return activeEvents[0].eventId;
}

char* cancel(EventScheduler* scheduler, char* eventId) {
    for (int i = 0; i < scheduler->count; i++) {
        if (scheduler->events[i].active && strcmp(scheduler->events[i].eventId, eventId) == 0) {
            scheduler->events[i].active = 0;
            return "CANCELLED";
        }
    }
    return "NOT_FOUND";
}

int main() {
    printf("[]");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

All operations use tree-based structures with O(log n) access, search, and modification

⚠ Quadratic Growth

Space Complexity

O(n)

Multiple sorted structures store the same n events with additional indexing

⚡ Linearithmic Space

34.5K Views

Medium Frequency

~35 min Avg. Time

887 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

Event Scheduler - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Balanced Approach with Sorted Structures — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler