LeetCode //C - 436. Find Right Interval

436. Find Right Interval

You are given an array of intervals, where $intervals[i]=[star{t}_i,en{d}_i]$ and each starti is unique.

The right interval for an interval i is an interval j such that $star{t}_j>=en{d}_i$ and startj is minimized. Note that i may equal j.

Return an array of right interval indices for each interval i. If no right interval exists for interval i, then put -1 at index i.
 

Example 1:

Input: intervals = [[1,2]]
Output: [-1]
Explanation: There is only one interval in the collection, so it outputs -1.

Example 2:

Input: intervals = [[3,4],[2,3],[1,2]]
Output: [-1,0,1]
Explanation: There is no right interval for [3,4].
The right interval for [2,3] is [3,4] since start0 = 3 is the smallest start that is >= end1 = 3.
The right interval for [1,2] is [2,3] since start1 = 2 is the smallest start that is >= end2 = 2.

Example 3:

Input: intervals = [[1,4],[2,3],[3,4]]
Output: [-1,2,-1]
Explanation: There is no right interval for [1,4] and [3,4].
The right interval for [2,3] is [3,4] since start2 = 3 is the smallest start that is >= end1 = 3.

Constraints:

• $1<=intervals.length<=2\ast 10^4$
• intervals[i].length == 2
• $-10^6<=starti<=endi<=10^6$
• The start point of each interval is unique.

From: LeetCode
Link: 436. Find Right Interval

Solution:

Ideas:

1. Create an array to store the original indices of the intervals since we’ll sort the intervals based on their start times but still need to return the indices based on the original input order.
2. Sort the intervals based on their start times while keeping track of their original indices.
3. For each interval, use binary search to find the smallest interval whose start time is greater than or equal to the current interval’s end time.
4. Populate the result array with the indices found in step 3. If no such interval is found, put -1 for that interval.
5. Return the result array.

Code:

int compare(const void* a, const void* b) {int* intervalA = *(int**)a;int* intervalB = *(int**)b;return intervalA[0] - intervalB[0];
}/*** Note: The returned array must be malloced, assume caller calls free().*/
int* findRightInterval(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize) {// Create an array to store the original index of each intervalint** intervalsWithIndex = (int**)malloc(intervalsSize * sizeof(int*));for (int i = 0; i < intervalsSize; i++) {intervalsWithIndex[i] = (int*)malloc(3 * sizeof(int)); // Increase size to store original indexintervalsWithIndex[i][0] = intervals[i][0]; // startintervalsWithIndex[i][1] = intervals[i][1]; // endintervalsWithIndex[i][2] = i; // original index}// Sort the intervals by their start timeqsort(intervalsWithIndex, intervalsSize, sizeof(int*), compare);// Allocate memory for the result array*returnSize = intervalsSize;int* result = (int*)malloc(intervalsSize * sizeof(int));// Binary search to find the right interval for each intervalfor (int i = 0; i < intervalsSize; i++) {int left = 0, right = intervalsSize - 1;int target = intervals[i][1];int found = -1;while (left <= right) {int mid = left + (right - left) / 2;if (intervalsWithIndex[mid][0] >= target) {found = intervalsWithIndex[mid][2];right = mid - 1;} else {left = mid + 1;}}result[i] = found;}// Free the allocated memoryfor (int i = 0; i < intervalsSize; i++) {free(intervalsWithIndex[i]);}free(intervalsWithIndex);return result;
}