Minimum Interval To Include Each Query - Leetcode Solution

Problem statement:

You are given an array of integers nums and an array queries, where queries[i] is a pair of indices (0-indexed). Find the minimum interval [l, r] such that for all queries[i], the subarray nums[l,r] contains A[queries[i][0]], A[queries[i][1]] and so on. A subarray (l,r) is called minimum if there is no subarray (l',r') such that r'-l' < r-l or l' < l or r' > r.

Solution:

The problem can be solved by using binary search and the sliding window algorithm in order to find the minimum interval. The idea of the solution is that we will find the minimum interval based on the maximum and minimum indices of the queries.

The steps are:

1. Create a dictionary that maps each number in the input array nums to a list of indices at which it is present.

2. For each query in the input array queries, create a list of indices for each element in the query. For example, if the query is [2, 4], create two lists [2nd index of element 2] and [4th index of element 4].

3. Find the minimum and maximum indices for each query. These indices will define the range of indices we need to consider.

4. For each index i in the input array nums, find the minimum and maximum indices of all the queries that include i. We can do this using the lists of indices we created in step 2 and the minimum and maximum indices we computed in step 3.

5. Using these minimum and maximum indices for each index i, we can use binary search to find the smallest interval that includes all the queries. We can do this by checking if there exists some j such that all the minimum indices of the queries that include i are less than or equal to j, and all the maximum indices are greater than or equal to j. If such a j exists, then we update our minimum interval. We continue this search until we find the smallest possible interval.

6. Finally, we return the minimum interval.

Time Complexity:

The time complexity of this algorithm is O(nlogn), where n is the length of the input array nums. The time complexity of creating the dictionary of indices for nums is O(n), and the time complexity of finding the minimum and maximum indices for each query is O(q), where q is the length of the input array queries. The time complexity of the binary search process is O(nlogn). Therefore, the total time complexity of the algorithm is O(nlogn).

Space Complexity:

The space complexity of this algorithm is O(n), where n is the length of the input array nums. The dictionary that maps each number to a list of indices has space complexity O(n), and the lists of indices for each query also have space complexity O(n). Therefore, the total space complexity of the algorithm is O(n).

1