# Queries to find the maximum and minimum array elements excluding elements from a given range

Last Updated : 08 Jun, 2021

Given an array arr[] consisting of N integers and an array Q[][] consisting of queries of the form [L, R]., the task for each query is to find the maximum and minimum array elements in the array excluding the elements from the given range.

Examples:

Input: arr[] = {2, 3, 1, 8, 3, 5, 7, 4}, Q[][] = {{4, 6}, {0, 4}, {3, 7}, {2, 5}}
Output:
8 1
7 4
3 1
7 2
Explanation:
Query 1: max(arr[0, 1, â€¦, 3], arr[7]) = 8 and min(arr[0, 1, â€¦, 3], arr[7]) = 1
Query 2: max(arr[5, 6, â€¦, 7]) = 7 and min(arr[5, 6, â€¦, 7]) = 4
Query 3: max(arr[0, 1, â€¦, 2]) =3 and min(arr[0, 1, â€¦, 2]) = 1
Query 4: max(arr[0, 1], arr[6, â€¦, 7]) =7 and min(arr[0, 1], arr[6, â€¦, 7]) = 2

Input: arr[] = {3, 2, 1, 4, 5}, Q[][] = {{1, 2}, {2, 4}}
Output:
5 3
3 2

Naive Approach: The simplest approach to solve the problem is to traverse the array for each query, and find the maximum and minimum elements present outside the range of indices [L, R].
Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: Divide the problem into subtasks by dividing the array into sub-ranges and find the maximum and minimum value from arr[0] to arr[L – 1] and from arr[r + 1] to arr[N – 1] and store them in a prefix and a suffix array respectively. Now find the maximum and minimum values for the given ranges by comparing the prefix and the suffix array.

• Traverse the array and maintain maximum and minimum elements encountered for every index in a 2D prefix array by comparing the value at the current index with the maximum and minimum values of the previous index.
• Now, iterate over the array in reverse and maintain maximum and minimum values for indices in 2D suffix array by comparing the value at the current index with the maximum and minimum values of the next index.
• Now, for each query, perform the following steps:
• If L = 0 and R = N – 1, then no element remains after excluding the range.
• Otherwise, if L = 0, the maximum and minimum value will be present between arr[R + 1] to arr[N – 1].
• Otherwise, if R = N – 1, the maximum and minimum value will be present between arr[0] to arr[L – 1].
• Otherwise, find the maximum and minimum values in the range arr[0] to arr[L – 1] and arr[R + 1] to arr[N – 1].
• Print the maximum and minimum values for this query.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the maximum and` `// minimum array elements up to the i-th index` `void` `prefixArr(``int` `arr[], ``int` `prefix[][2], ``int` `N)` `{`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``if` `(i == 0) {` `            ``prefix[i][0] = arr[i];` `            ``prefix[i][1] = arr[i];` `        ``}`   `        ``else` `{`   `            ``// Compare current value with maximum` `            ``// and minimum values up to previous index` `            ``prefix[i][0] = max(prefix[i - 1][0], arr[i]);` `            ``prefix[i][1] = min(prefix[i - 1][1], arr[i]);` `        ``}` `    ``}` `}`   `// Function to find the maximum and` `// minimum array elements from i-th index` `void` `suffixArr(``int` `arr[], ``int` `suffix[][2], ``int` `N)` `{`   `    ``// Traverse the array in reverse` `    ``for` `(``int` `i = N - 1; i >= 0; i--) {`   `        ``if` `(i == N - 1) {` `            ``suffix[i][0] = arr[i];` `            ``suffix[i][1] = arr[i];` `        ``}` `        ``else` `{`   `            ``// Compare current value with maximum` `            ``// and minimum values in the next index` `            ``suffix[i][0] = max(suffix[i + 1][0], arr[i]);` `            ``suffix[i][1] = min(suffix[i + 1][1], arr[i]);` `        ``}` `    ``}` `}`   `// Function to find the maximum and` `// minimum array elements for each query` `void` `maxAndmin(``int` `prefix[][2],` `               ``int` `suffix[][2],` `               ``int` `N, ``int` `L, ``int` `R)` `{`   `    ``int` `maximum, minimum;`   `    ``// If no index remains after` `    ``// excluding the elements` `    ``// in a given range` `    ``if` `(L == 0 && R == N - 1) {` `        ``cout << ``"No maximum and minimum value"` `<< endl;` `        ``return``;` `    ``}`   `    ``// Find maximum and minimum from` `    ``// from the range [R + 1, N - 1]` `    ``else` `if` `(L == 0) {` `        ``maximum = suffix[R + 1][0];` `        ``minimum = suffix[R + 1][1];` `    ``}`   `    ``// Find maximum and minimum from` `    ``// from the range [0, N - 1]` `    ``else` `if` `(R == N - 1) {` `        ``maximum = prefix[L - 1][0];` `        ``minimum = prefix[R - 1][1];` `    ``}`   `    ``// Find maximum and minimum values from the` `    ``// ranges [0, L - 1] and [R + 1, N - 1]` `    ``else` `{` `        ``maximum = max(prefix[L - 1][0],` `                      ``suffix[R + 1][0]);` `        ``minimum = min(prefix[L - 1][1],` `                      ``suffix[R + 1][1]);` `    ``}`   `    ``// Print the maximum and minimum value` `    ``cout << maximum << ``" "` `<< minimum << endl;` `}`   `// Function to perform queries to find the` `// minimum and maximum array elements excluding` `// elements from a given range` `void` `MinMaxQueries(``int` `a[], ``int` `Q[][])` `{`   `    ``// Size of the array` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Size of query array` `    ``int` `q = ``sizeof``(queries) / ``sizeof``(queries[0]);`   `    ``// prefix[i][0]: Stores the maximum` `    ``// prefix[i][1]: Stores the minimum value` `    ``int` `prefix[N][2];`   `    ``// suffix[i][0]: Stores the maximum` `    ``// suffix[i][1]: Stores the minimum value` `    ``int` `suffix[N][2];`   `    ``// Function calls to store` `    ``// maximum and minimum values` `    ``// for respective ranges` `    ``prefixArr(arr, prefix, N);` `    ``suffixArr(arr, suffix, N);`   `    ``for` `(``int` `i = 0; i < q; i++) {`   `        ``int` `L = queries[i][0];` `        ``int` `R = queries[i][1];`   `        ``maxAndmin(prefix, suffix, N, L, R);` `    ``}` `}`   `// Driver Code` `int` `main()` `{`   `    ``// Given array` `    ``int` `arr[] = { 2, 3, 1, 8, 3, 5, 7, 4 };`   `    ``int` `queries[][2]` `        ``= { { 4, 6 }, { 0, 4 }, { 3, 7 }, { 2, 5 } };`   `    ``MinMaxQueries(arr, Q);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `public` `class` `GFG` `{`   `  ``// Function to find the maximum and` `  ``// minimum array elements up to the i-th index` `  ``static` `void` `prefixArr(``int` `arr[], ``int` `prefix[][], ``int` `N)` `  ``{`   `    ``// Traverse the array` `    ``for` `(``int` `i = ``0``; i < N; i++)` `    ``{` `      ``if` `(i == ``0``)` `      ``{` `        ``prefix[i][``0``] = arr[i];` `        ``prefix[i][``1``] = arr[i];` `      ``}` `      ``else` `      ``{`   `        ``// Compare current value with maximum` `        ``// and minimum values up to previous index` `        ``prefix[i][``0``] = Math.max(prefix[i - ``1``][``0``], arr[i]);` `        ``prefix[i][``1``] = Math.min(prefix[i - ``1``][``1``], arr[i]);` `      ``}` `    ``}` `  ``}`   `  ``// Function to find the maximum and` `  ``// minimum array elements from i-th index` `  ``static` `void` `suffixArr(``int` `arr[], ``int` `suffix[][], ``int` `N)` `  ``{`   `    ``// Traverse the array in reverse` `    ``for` `(``int` `i = N - ``1``; i >= ``0``; i--) ` `    ``{` `      ``if` `(i == N - ``1``)` `      ``{` `        ``suffix[i][``0``] = arr[i];` `        ``suffix[i][``1``] = arr[i];` `      ``}` `      ``else` `      ``{`   `        ``// Compare current value with maximum` `        ``// and minimum values in the next index` `        ``suffix[i][``0``] = Math.max(suffix[i + ``1``][``0``], arr[i]);` `        ``suffix[i][``1``] = Math.min(suffix[i + ``1``][``1``], arr[i]);` `      ``}` `    ``}` `  ``}`   `  ``// Function to find the maximum and` `  ``// minimum array elements for each query` `  ``static` `void` `maxAndmin(``int` `prefix[][],` `                        ``int` `suffix[][],` `                        ``int` `N, ``int` `L, ``int` `R)` `  ``{` `    ``int` `maximum, minimum;`   `    ``// If no index remains after` `    ``// excluding the elements` `    ``// in a given range` `    ``if` `(L == ``0` `&& R == N - ``1``)` `    ``{` `      ``System.out.println(``"No maximum and minimum value"``);` `      ``return``;` `    ``}`   `    ``// Find maximum and minimum from` `    ``// from the range [R + 1, N - 1]` `    ``else` `if` `(L == ``0``) ` `    ``{` `      ``maximum = suffix[R + ``1``][``0``];` `      ``minimum = suffix[R + ``1``][``1``];` `    ``}`   `    ``// Find maximum and minimum from` `    ``// from the range [0, N - 1]` `    ``else` `if` `(R == N - ``1``)` `    ``{` `      ``maximum = prefix[L - ``1``][``0``];` `      ``minimum = prefix[R - ``1``][``1``];` `    ``}`   `    ``// Find maximum and minimum values from the` `    ``// ranges [0, L - 1] and [R + 1, N - 1]` `    ``else` `    ``{` `      ``maximum = Math.max(prefix[L - ``1``][``0``],` `                         ``suffix[R + ``1``][``0``]);` `      ``minimum = Math.min(prefix[L - ``1``][``1``],` `                         ``suffix[R + ``1``][``1``]);` `    ``}`   `    ``// Print the maximum and minimum value` `    ``System.out.println(maximum + ``" "` `+ minimum);` `  ``}`   `  ``// Function to perform queries to find the` `  ``// minimum and maximum array elements excluding` `  ``// elements from a given range` `  ``static` `void` `MinMaxQueries(``int` `a[], ``int` `Q[][])` `  ``{`   `    ``// Size of the array` `    ``int` `N = a.length;`   `    ``// Size of query array` `    ``int` `q = Q.length;`   `    ``// prefix[i][0]: Stores the maximum` `    ``// prefix[i][1]: Stores the minimum value` `    ``int` `prefix[][] = ``new` `int``[N][``2``];`   `    ``// suffix[i][0]: Stores the maximum` `    ``// suffix[i][1]: Stores the minimum value` `    ``int` `suffix[][] = ``new` `int``[N][``2``];`   `    ``// Function calls to store` `    ``// maximum and minimum values` `    ``// for respective ranges` `    ``prefixArr(a, prefix, N);` `    ``suffixArr(a, suffix, N);`   `    ``for` `(``int` `i = ``0``; i < q; i++)` `    ``{` `      ``int` `L = Q[i][``0``];` `      ``int` `R = Q[i][``1``];` `      ``maxAndmin(prefix, suffix, N, L, R);` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main (String[] args)` `  ``{`   `    ``// Given array` `    ``int` `arr[] = { ``2``, ``3``, ``1``, ``8``, ``3``, ``5``, ``7``, ``4` `};`   `    ``int` `queries[][]` `      ``= { { ``4``, ``6` `}, { ``0``, ``4` `}, { ``3``, ``7` `}, { ``2``, ``5` `} };`   `    ``MinMaxQueries(arr, queries);` `  ``}` `}`   `// This code is contributed by AnkThon`

## Python3

 `# Python3 program for the above approach`   `# Function to find the maximum and` `# minimum array elements up to the i-th index` `def` `prefixArr(arr, prefix, N):`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(N):` `        ``if` `(i ``=``=` `0``):` `            ``prefix[i][``0``] ``=` `arr[i]` `            ``prefix[i][``1``] ``=` `arr[i]`   `        ``else``:`   `            ``# Compare current value with maximum` `            ``# and minimum values up to previous index` `            ``prefix[i][``0``] ``=` `max``(prefix[i ``-` `1``][``0``], arr[i])` `            ``prefix[i][``1``] ``=` `min``(prefix[i ``-` `1``][``1``], arr[i])` `    ``return` `prefix`     `# Function to find the maximum and` `# minimum array elements from i-th index` `def` `suffixArr(arr, suffix, N):`   `    ``# Traverse the array in reverse` `    ``for` `i ``in` `range``(N ``-` `1``, ``-``1``, ``-``1``):`   `        ``if` `(i ``=``=` `N ``-` `1``):` `            ``suffix[i][``0``] ``=` `arr[i]` `            ``suffix[i][``1``] ``=` `arr[i]`   `        ``else``:`   `            ``# Compare current value with maximum` `            ``# and minimum values in the next index` `            ``suffix[i][``0``] ``=` `max``(suffix[i ``+` `1``][``0``], arr[i])` `            ``suffix[i][``1``] ``=` `min``(suffix[i ``+` `1``][``1``], arr[i])` `    ``return` `suffix`   `# Function to find the maximum and` `# minimum array elements for each query` `def` `maxAndmin(prefix, suffix, N, L, R):` `    ``maximum, minimum ``=` `0``, ``0`   `    ``# If no index remains after` `    ``# excluding the elements` `    ``# in a given range` `    ``if` `(L ``=``=` `0` `and` `R ``=``=` `N ``-` `1``):` `        ``print``(``"No maximum and minimum value"``)` `        ``return`   `    ``# Find maximum and minimum from` `    ``# from the range [R + 1, N - 1]` `    ``elif` `(L ``=``=` `0``):` `        ``maximum ``=` `suffix[R ``+` `1``][``0``]` `        ``minimum ``=` `suffix[R ``+` `1``][``1``]`   `    ``# Find maximum and minimum from` `    ``# from the range [0, N - 1]` `    ``elif` `(R ``=``=` `N ``-` `1``):` `        ``maximum ``=` `prefix[L ``-` `1``][``0``]` `        ``minimum ``=` `prefix[R ``-` `1``][``1``]`   `    ``# Find maximum and minimum values from the` `    ``# ranges [0, L - 1] and [R + 1, N - 1]` `    ``else``:` `        ``maximum ``=` `max``(prefix[L ``-` `1``][``0``], suffix[R ``+` `1``][``0``])` `        ``minimum ``=` `min``(prefix[L ``-` `1``][``1``], suffix[R ``+` `1``][``1``])`   `    ``# Print maximum and minimum value` `    ``print``(maximum, minimum)`   `# Function to perform queries to find the` `# minimum and maximum array elements excluding` `# elements from a given range` `def` `MinMaxQueries(a, queries):`   `    ``# Size of the array` `    ``N ``=` `len``(arr)`   `    ``# Size of query array` `    ``q ``=` `len``(queries)`   `    ``# prefix[i][0]: Stores the maximum` `    ``# prefix[i][1]: Stores the minimum value` `    ``prefix ``=` `[ [ ``0` `for` `i ``in` `range``(``2``)] ``for` `i ``in` `range``(N)]`   `    ``# suffix[i][0]: Stores the maximum` `    ``# suffix[i][1]: Stores the minimum value` `    ``suffix ``=` `[ [ ``0` `for` `i ``in` `range``(``2``)] ``for` `i ``in` `range``(N)]`   `    ``# Function calls to store` `    ``# maximum and minimum values` `    ``# for respective ranges` `    ``prefix ``=` `prefixArr(arr, prefix, N)` `    ``suffix ``=` `suffixArr(arr, suffix, N)`   `    ``for` `i ``in` `range``(q):` `        ``L ``=` `queries[i][``0``]` `        ``R ``=` `queries[i][``1``]`   `        ``maxAndmin(prefix, suffix, N, L, R)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# Given array` `    ``arr ``=` `[ ``2``, ``3``, ``1``, ``8``, ``3``, ``5``, ``7``, ``4` `]` `    ``queries ``=` `[ [ ``4``, ``6` `], [ ``0``, ``4` `], [ ``3``, ``7` `], [ ``2``, ``5` `] ]` `    ``MinMaxQueries(arr, queries)`   `    ``# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach` `using` `System;` `public` `class` `GFG` `{`   `  ``// Function to find the maximum and` `  ``// minimum array elements up to the i-th index` `  ``static` `void` `prefixArr(``int``[] arr, ``int``[,] prefix, ``int` `N)` `  ``{`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++)` `    ``{` `      ``if` `(i == 0)` `      ``{` `        ``prefix[i, 0] = arr[i];` `        ``prefix[i, 1] = arr[i];` `      ``}` `      ``else` `      ``{`   `        ``// Compare current value with maximum` `        ``// and minimum values up to previous index` `        ``prefix[i, 0] = Math.Max(prefix[i - 1, 0], arr[i]);` `        ``prefix[i, 1] = Math.Min(prefix[i - 1, 1], arr[i]);` `      ``}` `    ``}` `  ``}`   `  ``// Function to find the maximum and` `  ``// minimum array elements from i-th index` `  ``static` `void` `suffixArr(``int``[] arr, ``int``[,] suffix, ``int` `N)` `  ``{`   `    ``// Traverse the array in reverse` `    ``for` `(``int` `i = N - 1; i >= 0; i--) ` `    ``{` `      ``if` `(i == N - 1)` `      ``{` `        ``suffix[i, 0] = arr[i];` `        ``suffix[i, 1] = arr[i];` `      ``}` `      ``else` `      ``{`   `        ``// Compare current value with maximum` `        ``// and minimum values in the next index` `        ``suffix[i, 0] = Math.Max(suffix[i + 1, 0], arr[i]);` `        ``suffix[i, 1] = Math.Min(suffix[i + 1, 1], arr[i]);` `      ``}` `    ``}` `  ``}`   `  ``// Function to find the maximum and` `  ``// minimum array elements for each query` `  ``static` `void` `maxAndmin(``int``[,] prefix,` `                        ``int``[,] suffix,` `                        ``int` `N, ``int` `L, ``int` `R)` `  ``{` `    ``int` `maximum, minimum;`   `    ``// If no index remains after` `    ``// excluding the elements` `    ``// in a given range` `    ``if` `(L == 0 && R == N - 1)` `    ``{` `      ``Console.WriteLine(``"No maximum and minimum value"``);` `      ``return``;` `    ``}`   `    ``// Find maximum and minimum from` `    ``// from the range [R + 1, N - 1]` `    ``else` `if` `(L == 0) ` `    ``{` `      ``maximum = suffix[R + 1, 0];` `      ``minimum = suffix[R + 1, 1];` `    ``}`   `    ``// Find maximum and minimum from` `    ``// from the range [0, N - 1]` `    ``else` `if` `(R == N - 1)` `    ``{` `      ``maximum = prefix[L - 1, 0];` `      ``minimum = prefix[R - 1, 1];` `    ``}`   `    ``// Find maximum and minimum values from the` `    ``// ranges [0, L - 1] and [R + 1, N - 1]` `    ``else` `    ``{` `      ``maximum = Math.Max(prefix[L - 1, 0],` `                         ``suffix[R + 1, 0]);` `      ``minimum = Math.Min(prefix[L - 1, 1],` `                         ``suffix[R + 1, 1]);` `    ``}`   `    ``// Print the maximum and minimum value` `    ``Console.WriteLine(maximum + ``" "` `+ minimum);` `  ``}`   `  ``// Function to perform queries to find the` `  ``// minimum and maximum array elements excluding` `  ``// elements from a given range` `  ``static` `void` `MinMaxQueries(``int``[] a, ``int``[,] Q)` `  ``{`   `    ``// Size of the array` `    ``int` `N = a.GetLength(0);`   `    ``// Size of query array` `    ``int` `q = Q.GetLength(0);`   `    ``// prefix[i][0]: Stores the maximum` `    ``// prefix[i][1]: Stores the minimum value` `    ``int``[,] prefix = ``new` `int``[N, 2];`   `    ``// suffix[i][0]: Stores the maximum` `    ``// suffix[i][1]: Stores the minimum value` `    ``int``[,] suffix = ``new` `int``[N, 2];`   `    ``// Function calls to store` `    ``// maximum and minimum values` `    ``// for respective ranges` `    ``prefixArr(a, prefix, N);` `    ``suffixArr(a, suffix, N);`   `    ``for` `(``int` `i = 0; i < q; i++)` `    ``{` `      ``int` `L = Q[i, 0];` `      ``int` `R = Q[i, 1];` `      ``maxAndmin(prefix, suffix, N, L, R);` `    ``}` `  ``}`   `  ``// Driver Code` `  ``static` `public` `void` `Main ()` `  ``{` `    `  `    ``// Given array` `    ``int``[] arr = { 2, 3, 1, 8, 3, 5, 7, 4 };` `    ``int``[,] queries = { { 4, 6 }, { 0, 4 }, ` `                      ``{ 3, 7 }, { 2, 5 } };` `    ``MinMaxQueries(arr, queries);` `  ``}` `}`   `// This code is contributed by sanjoy_62.`

## Javascript

 ``

Output:

```8 1
7 4
3 1
7 2```

Time Complexity: O(N)
Auxiliary Space: O(N)

Previous
Next