LeetCode 436. Find Right Interval

Problem Statement

Given a set of intervals, for each of the interval i, check if there exists an interval j whose start point is bigger than or equal to the end point of the interval i, which can be called that j is on the “right” of i.

For any interval i, you need to store the minimum interval j’s index, which means that the interval j has the minimum start point to build the “right” relationship for interval i. If the interval j doesn’t exist, store -1 for the interval i. Finally, you need output the stored value of each interval as an array.

Note:

1. You may assume the interval’s end point is always bigger than its start point.
2. You may assume none of these intervals have the same start point.

Example 1:

Input: [ [1,2] ]

Output: [-1]

Explanation: There is only one interval in the collection, so it outputs -1.

Example 2:

Input: [ [3,4], [2,3], [1,2] ]

Output: [-1, 0, 1]

Explanation: There is no satisfied "right" interval for [3,4].
For [2,3], the interval [3,4] has minimum-"right" start point;
For [1,2], the interval [2,3] has minimum-"right" start point.
Example 3:
Input: [ [1,4], [2,3], [3,4] ]

Output: [-1, 2, -1]

Explanation: There is no satisfied "right" interval for [1,4] and [3,4].
For [2,3], the interval [3,4] has minimum-"right" start point.

Solution

Tags: Binary Search.

I got stuck about the problem due toTLE for a while ): After a careful re-reading of the problem statement, I found:

Note:

1. You may assume the interval’s end point is always bigger than its start point.
2. You may assume none of these intervals have the same start point.

These are the critical points to go! Self-explained code is attached below.

# Definition for an interval.
# class Interval(object):
#     def __init__(self, s=0, e=0):
#         self.start = s
#         self.end = e

class Solution(object):    
    def findRightInterval(self, intervals):
        """
        :type intervals: List[Interval]
        :rtype: List[int]
        """
        from bisect import bisect_left

        n = len(intervals)
        res = [-1] * n
        starts = []
        m = {}
        for i, interval in enumerate(intervals):
            starts.append(interval.start)
            m[interval.start] = i
        starts.sort()
        for i in xrange(n):
            pos = bisect_left(starts, intervals[i].end)
            if pos < n:
                res[i] = m[starts[pos]]
        return res

Complexity Analysis:

• Time Complexity: $O(nlogn)$.
• Space Complexity: $O(n)$.