# Largest interval in an Array that contains the given element X for Q queries

Given an array arr[] of N elements and Q queries of the form [X]. For each query, the task is to find the largest interval [L, R] of the array such that the greatest element in the interval is arr[X], such that 1 ≤ L ≤ X ≤ R.
Note: The array has 1-based indexing.

Examples:

Input: N = 5, arr[] = {2, 1, 2, 3, 2}, Q = 3, query[] = {1, 2, 4}
Output:
[1, 3]
[2, 2]
[1, 5]
Explanation :
In 1st query, x = 1, so arr[x] = 2 and answer is L = 1 and R = 3. here, we can see that max(arr, arr, arr) = arr[x], which is the maximum intervals.
In 2nd query, x = 2, so arr[x] = 1 and since it is the smallest element of the array, so the interval contains only one element, thus the range is [2, 2].
In 3rd query, x = 4, so arr[x] = 4, which is maximum element of the arr[], so the answer is whole array, L = 1 and R = N.

Input: N = 4, arr[] = { 1, 2, 2, 4}, Q = 2, query[] = {1, 2}
Output:
[1, 1]
[1, 3]
Explanation:
In 1st query, x = 1, so arr[x] = 1 and since it is the smallest element of the array, so the interval contains only one element, thus the range is [1, 1].
In 2nd query, x = 2, so arr[x] = 2 and answer is L = 1 and R = 3. here, we can see that max(arr, arr, arr) = arr[x] = arr = 2, which is the maximum intervals.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The idea is to precompute the largest interval for every value K in arr[] from 1 to N. Below are the steps:

1. For each element K in arr[], fix the index of the element K, then find how much we can extend the interval to it’s left and right.
2. Decrement left iterator till arr[left] ≤ K and similarly increment right iterator till arr[right] ≤ K.
3. The final value of left and right represents the starting and the ending index of the interval, which is stored in arrL[] and arrR[] respectively.
4. After we have precomputed interval range for each value. Then, for each query, we need to print the interval range for arr[x] i.e., arrL[arr[x]] and arrR[arr[x]].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to precompute the interval ` `// for each query ` `void` `utilLargestInterval(``int` `arr[], ` `                         ``int` `arrL[], ` `                         ``int` `arrR[], ` `                         ``int` `N) ` `{ ` ` `  `    ``// For every values [1, N] find ` `    ``// the longest intervals ` `    ``for` `(``int` `maxValue = 1; ` `         ``maxValue <= N; maxValue++) { ` ` `  `        ``int` `lastIndex = 0; ` ` `  `        ``// Iterate the array arr[] ` `        ``for` `(``int` `i = 1; i <= N; i++) { ` ` `  `            ``if` `(lastIndex >= i ` `                ``|| arr[i] != maxValue) ` `                ``continue``; ` `            ``int` `left = i, right = i; ` ` `  `            ``// Shift the left pointers ` `            ``while` `(left > 0 ` `                   ``&& arr[left] <= maxValue) ` `                ``left--; ` ` `  `            ``// Shift the right pointers ` `            ``while` `(right <= N ` `                   ``&& arr[right] <= maxValue) ` `                ``right++; ` ` `  `            ``left++, right--; ` `            ``lastIndex = right; ` ` `  `            ``// Store the range of interval ` `            ``// in arrL[] and arrR[]. ` `            ``for` `(``int` `j = left; j <= right; j++) { ` ` `  `                ``if` `(arr[j] == maxValue) { ` `                    ``arrL[j] = left; ` `                    ``arrR[j] = right; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// Function to find the largest interval ` `// for each query in Q[] ` `void` `largestInterval( ` `    ``int` `arr[], ``int` `query[], ``int` `N, ``int` `Q) ` `{ ` ` `  `    ``// To store the L and R of X ` `    ``int` `arrL[N + 1], arrR[N + 1]; ` ` `  `    ``// Function Call ` `    ``utilLargestInterval(arr, arrL, ` `                        ``arrR, N); ` ` `  `    ``// Iterate to find ranges for each query ` `    ``for` `(``int` `i = 0; i < Q; i++) { ` ` `  `        ``cout << ``"["` `<< arrL[query[i]] ` `             ``<< ``", "` `<< arrR[query[i]] ` `             ``<< ``"]\n"``; ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `N = 5, Q = 3; ` ` `  `    ``// Given array arr[] ` `    ``int` `arr[N + 1] = { 0, 2, 1, 2, 3, 2 }; ` ` `  `    ``// Given Queries ` `    ``int` `query[Q] = { 1, 2, 4 }; ` ` `  `    ``// Function Call ` `    ``largestInterval(arr, query, N, Q); ` `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `class` `GFG{ ` ` `  `// Function to precompute the interval ` `// for each query ` `static` `void` `utilLargestInterval(``int` `arr[], ` `                                ``int` `arrL[], ` `                                ``int` `arrR[], ` `                                ``int` `N) ` `{ ` ` `  `    ``// For every values [1, N] find ` `    ``// the longest intervals ` `    ``for``(``int` `maxValue = ``1``; ` `            ``maxValue <= N; maxValue++) ` `    ``{ ` `       ``int` `lastIndex = ``0``; ` `        `  `       ``// Iterate the array arr[] ` `       ``for``(``int` `i = ``1``; i <= N; i++)  ` `       ``{ ` `          ``if` `(lastIndex >= i ||  ` `                 ``arr[i] != maxValue) ` `              ``continue``; ` `          ``int` `left = i, right = i; ` `           `  `          ``// Shift the left pointers ` `          ``while` `(left > ``0` `&&  ` `                 ``arr[left] <= maxValue) ` `              ``left--; ` `           `  `          ``// Shift the right pointers ` `          ``while` `(right <= N &&  ` `                 ``arr[right] <= maxValue) ` `              ``right++; ` `           `  `          ``left++;  ` `          ``right--; ` `          ``lastIndex = right; ` `           `  `          ``// Store the range of interval ` `          ``// in arrL[] and arrR[]. ` `          ``for``(``int` `j = left; j <= right; j++) ` `          ``{ ` `             ``if` `(arr[j] == maxValue) ` `             ``{ ` `                 ``arrL[j] = left; ` `                 ``arrR[j] = right; ` `             ``} ` `          ``} ` `       ``} ` `    ``} ` `} ` ` `  `// Function to find the largest interval ` `// for each query in Q[] ` `static` `void` `largestInterval(``int` `arr[], ` `                            ``int` `query[],  ` `                            ``int` `N, ``int` `Q) ` `{ ` `     `  `    ``// To store the L and R of X ` `    ``int` `[]arrL = ``new` `int``[N + ``1``]; ` `    ``int` `[]arrR = ``new` `int``[N + ``1``]; ` ` `  `    ``// Function Call ` `    ``utilLargestInterval(arr, arrL, ` `                        ``arrR, N); ` ` `  `    ``// Iterate to find ranges for  ` `    ``// each query ` `    ``for``(``int` `i = ``0``; i < Q; i++)  ` `    ``{ ` `       ``System.out.print(``"["` `+ arrL[query[i]] +  ` `                       ``", "` `+ arrR[query[i]] + ``"]\n"``); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `N = ``5``, Q = ``3``; ` ` `  `    ``// Given array arr[] ` `    ``int` `arr[] = { ``0``, ``2``, ``1``, ``2``, ``3``, ``2` `}; ` ` `  `    ``// Given queries ` `    ``int` `query[] = { ``1``, ``2``, ``4` `}; ` ` `  `    ``// Function call ` `    ``largestInterval(arr, query, N, Q); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar `

## C#

 `// C# program for the above approach ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `// Function to precompute the interval ` `// for each query ` `static` `void` `utilLargestInterval(``int` `[]arr, ` `                                ``int` `[]arrL, ` `                                ``int` `[]arrR, ` `                                ``int` `N) ` `{ ` ` `  `    ``// For every values [1, N] find ` `    ``// the longest intervals ` `    ``for``(``int` `maxValue = 1; ` `            ``maxValue <= N; maxValue++) ` `    ``{ ` `       ``int` `lastIndex = 0; ` `        `  `       ``// Iterate the array []arr ` `       ``for``(``int` `i = 1; i <= N; i++) ` `       ``{ ` `          ``if` `(lastIndex >= i ||  ` `                 ``arr[i] != maxValue) ` `              ``continue``; ` `               `  `          ``int` `left = i, right = i; ` `           `  `          ``// Shift the left pointers ` `          ``while` `(left > 0 &&  ` `                 ``arr[left] <= maxValue) ` `              ``left--; ` `               `  `          ``// Shift the right pointers ` `          ``while` `(right <= N &&  ` `                 ``arr[right] <= maxValue) ` `              ``right++; ` `           `  `          ``left++;  ` `          ``right--; ` `          ``lastIndex = right; ` `           `  `          ``// Store the range of interval ` `          ``// in arrL[] and arrR[]. ` `          ``for``(``int` `j = left; j <= right; j++) ` `          ``{ ` `             ``if` `(arr[j] == maxValue) ` `             ``{ ` `                 ``arrL[j] = left; ` `                 ``arrR[j] = right; ` `             ``} ` `          ``} ` `       ``} ` `    ``} ` `} ` ` `  `// Function to find the largest interval ` `// for each query in Q[] ` `static` `void` `largestInterval(``int` `[]arr, ` `                            ``int` `[]query,  ` `                            ``int` `N, ``int` `Q) ` `{ ` `     `  `    ``// To store the L and R of X ` `    ``int` `[]arrL = ``new` `int``[N + 1]; ` `    ``int` `[]arrR = ``new` `int``[N + 1]; ` ` `  `    ``// Function Call ` `    ``utilLargestInterval(arr, arrL, ` `                        ``arrR, N); ` ` `  `    ``// Iterate to find ranges for  ` `    ``// each query ` `    ``for``(``int` `i = 0; i < Q; i++)  ` `    ``{ ` `       ``Console.Write(``"["` `+ arrL[query[i]] +  ` `                    ``", "` `+ arrR[query[i]] + ``"]\n"``); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `N = 5, Q = 3; ` ` `  `    ``// Given array []arr ` `    ``int` `[]arr = { 0, 2, 1, 2, 3, 2 }; ` ` `  `    ``// Given queries ` `    ``int` `[]query = { 1, 2, 4 }; ` ` `  `    ``// Function call ` `    ``largestInterval(arr, query, N, Q); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

```[1, 3]
[2, 2]
[1, 5]
```

Time Complexity: O(Q + N2)
Auxillary Space: O(N) My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.