Reschedule Meetings for Maximum Free Time I

Reschedule Meetings for Maximum Free Time I - Problem

Meeting Scheduler Challenge: You're managing a busy schedule during an event that runs from t = 0 to t = eventTime. You have n non-overlapping meetings already scheduled, where the i-th meeting runs from startTime[i] to endTime[i].

Here's the twist: you can reschedule at most k meetings by moving their start times (while keeping the same duration) to create the longest possible continuous block of free time. However, there are important constraints:

• Relative order must be preserved - you can't swap meetings around
• Meetings must remain non-overlapping
• All meetings must stay within the event timeframe

Your goal is to find the maximum amount of continuous free time you can create by strategically rescheduling up to k meetings. Think of it as Tetris for your calendar - how can you rearrange the pieces to create the biggest gap?

Input & Output

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(C(n,k) * n^k)	O(k)	Try all possible ways to reschedule k meetings and find the maximum free time
Greedy Gap Maximization (Optimal)	O(n log n)	O(n)	Greedily select meetings that create maximum gap when rescheduled optimally
Sliding Window with Two Pointers	O(n²)	O(n)	Use sliding window to find optimal k consecutive meetings to reschedule

Brute Force (Try All Combinations) — Algorithm Steps

Generate all combinations of k meetings from n total meetings
For each combination, try all valid rescheduling positions
Check that rescheduled meetings maintain relative order and don't overlap
Calculate the maximum continuous free time for each valid arrangement
Return the maximum free time found across all arrangements

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Schedule

Start with the given meeting arrangement

Generate Combinations

Create all possible combinations of k meetings to reschedule

Try Positions

For each combination, try all valid rescheduling positions

Calculate Free Time

Compute maximum continuous free time for each arrangement

Find Maximum

Return the arrangement with maximum free time

Code -

solution.c — C

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

typedef struct {
    int start, end;
} Meeting;

int compare(const void* a, const void* b) {
    Meeting* ma = (Meeting*)a;
    Meeting* mb = (Meeting*)b;
    return ma->start - mb->start;
}

int calculateMaxFreeTime(int eventTime, int* startTime, int* endTime, int* durations, int n, int* toReschedule, int rescheduleCount) {
    Meeting meetings[100];
    int meetingCount = 0;
    bool isRescheduled[100] = {false};
    
    for (int i = 0; i < rescheduleCount; i++) {
        isRescheduled[toReschedule[i]] = true;
    }
    
    for (int i = 0; i < n; i++) {
        if (!isRescheduled[i]) {
            meetings[meetingCount].start = startTime[i];
            meetings[meetingCount].end = endTime[i];
            meetingCount++;
        }
    }
    
    for (int i = 0; i < rescheduleCount; i++) {
        int idx = toReschedule[i];
        for (int p = 0; p <= eventTime - durations[idx]; p++) {
            bool canPlace = true;
            for (int j = 0; j < meetingCount; j++) {
                if (!(p + durations[idx] <= meetings[j].start || p >= meetings[j].end)) {
                    canPlace = false;
                    break;
                }
            }
            if (canPlace) {
                meetings[meetingCount].start = p;
                meetings[meetingCount].end = p + durations[idx];
                meetingCount++;
                break;
            }
        }
    }
    
    qsort(meetings, meetingCount, sizeof(Meeting), compare);
    
    int maxGap = meetingCount == 0 ? eventTime : meetings[0].start;
    for (int i = 1; i < meetingCount; i++) {
        int gap = meetings[i].start - meetings[i-1].end;
        if (gap > maxGap) maxGap = gap;
    }
    if (meetingCount > 0) {
        int endGap = eventTime - meetings[meetingCount-1].end;
        if (endGap > maxGap) maxGap = endGap;
    }
    
    return maxGap;
}

int solve(int eventTime, int* startTime, int* endTime, int* durations, int n, int k, int idx, int* toReschedule, int rescheduled) {
    if (rescheduled == k || idx == n) {
        return calculateMaxFreeTime(eventTime, startTime, endTime, durations, n, toReschedule, rescheduled);
    }
    
    int maxFree = solve(eventTime, startTime, endTime, durations, n, k, idx + 1, toReschedule, rescheduled);
    
    if (rescheduled < k) {
        toReschedule[rescheduled] = idx;
        int withReschedule = solve(eventTime, startTime, endTime, durations, n, k, idx + 1, toReschedule, rescheduled + 1);
        if (withReschedule > maxFree) maxFree = withReschedule;
    }
    
    return maxFree;
}

int maxFreeTime(int eventTime, int* startTime, int* endTime, int n, int k) {
    int durations[100];
    for (int i = 0; i < n; i++) {
        durations[i] = endTime[i] - startTime[i];
    }
    
    int toReschedule[100];
    return solve(eventTime, startTime, endTime, durations, n, k, 0, toReschedule, 0);
}

int main() {
    int eventTime, k, n;
    scanf("%d %d", &eventTime, &k);
    scanf("%d", &n);
    
    int startTime[100], endTime[100];
    for (int i = 0; i < n; i++) {
        scanf("%d", &startTime[i]);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", &endTime[i]);
    }
    
    printf("%d\n", maxFreeTime(eventTime, startTime, endTime, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * n^k)

C(n,k) combinations times n^k possible positions for each combination

✓ Linear Growth

Space Complexity

O(k)

Space to store current combination and temporary arrangements

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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