Related Articles
Maximum MEX from all subarrays of length K
• Difficulty Level : Medium
• Last Updated : 23 Nov, 2020

Given an array arr[] consisting of N distinct integers and an integer K, the task is to find the maximum MEX from all subarrays of length K.

Examples:

Input: arr[] = {3, 2, 1, 4}, K = 2
Output: 3
Explanation:
All subarrays having length 2 are {3, 2}, {2, 1}, {1, 4}.
In subarray {3, 2}, the smallest positive integer which is not present is 1.
In subarray {2, 1}, the smallest positive integer which is not present is 3.
In subarray {1, 4}, the smallest positive integer which is not present is 2.

Input: arr[] = {6, 1, 3, 2, 4}, K = 3
Output: 4
Explanation:
All subarrays having length 3 are {6, 1, 3}, {1, 3, 2}, {3, 2, 4}
In subarray {6, 1, 3}, the smallest positive integer which is not present is 2.
In subarray {1, 3, 2}, the smallest positive integer which is not present is 4.
In subarray {3, 2, 4}, the smallest positive integer which is not present is 1.

Naive Approach: The simplest approach is to generate all subarrays of length K and find MEX of every subarray. After finding all the MEX, print the maximum of those obtained.

Time Complexity: O(K * N2)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use the data structure Set and Sliding Window Technique. Follow the steps below to solve the problem:

• Initialize a set S to store values that are not present in the current subarray and initially insert 1 to N + 1 number in it because initially, the size of the window is 0.
• Traverse over the range [0, K – 1] and erase arr[i] from the set, the first element of the set is MEX of subarray starting from index 0 and length K, initialize a variable mex and store this value in mex.
• Now iterate from K to N – 1 and insert arr[i] to set and erase arr[i – K] from it and update mex = max(mex, first element of set).
• After the above steps, print mex as maximum MEX among subarray having length K.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to return maximum MEX of` `// all K length subarray` `void` `maxMEX(``int` `arr[], ``int` `N, ``int` `K)` `{` `    ``// Stores element from 1 to N + 1` `    ``// is nor present in subarray` `    ``set<``int``> s;`   `    ``// Store number 1 to N + 1 in set s` `    ``for` `(``int` `i = 1; i <= N + 1; i++)` `        ``s.insert(i);`   `    ``// Find the MEX of K length subarray` `    ``// starting from index 0` `    ``for` `(``int` `i = 0; i < K; i++)` `        ``s.erase(arr[i]);`   `    ``int` `mex = *(s.begin());`   `    ``// Find the MEX of all subarray of` `    ``// length K by erasing arr[i]` `    ``// and inserting arr[i-K]` `    ``for` `(``int` `i = K; i < N; i++) {` `        ``s.erase(arr[i]);`   `        ``s.insert(arr[i - K]);`   `        ``// Store first element of set` `        ``int` `firstElem = *(s.begin());`   `        ``// Updating mex` `        ``mex = max(mex, firstElem);` `    ``}`   `    ``// Print maximum MEX of all K` `    ``// length subarray` `    ``cout << mex << ``' '``;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array` `    ``int` `arr[] = { 3, 2, 1, 4 };`   `    ``// Given length of subarray` `    ``int` `K = 2;`   `    ``// Size of the array` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``// Function Call` `    ``maxMEX(arr, N, K);`   `    ``return` `0;` `}`

## Java

 `// Java program for the` `// above approach` `import` `java.util.*;` `class` `GFG {`   `    ``// Function to return maximum` `    ``// MEX of all K length subarray` `    ``static` `void` `maxMEX(``int` `arr[], ``int` `N, ``int` `K)` `    ``{` `        ``// Stores element from` `        ``// 1 to N + 1 is nor` `        ``// present in subarray` `      `  `        ``// We need a Tree Set since` `        ``// we want to store the` `        ``// elements in ascending` `        ``// order` `        ``Set s = ``new` `TreeSet<>(); `   `        ``// Store number 1 to` `        ``// N + 1 in set s` `        ``for` `(``int` `i = ``1``; i <= N + ``1``; i++)` `            ``s.add(i);`   `        ``// Find the MEX of K length` `        ``// subarray starting from index 0` `        ``for` `(``int` `i = ``0``; i < K; i++)` `            ``s.remove(arr[i]);`   `        ``int` `mex = ``0``;` `      `  `        ``// Extracting first element from set` `        ``for` `(``int` `e : s) ` `        ``{` `            ``mex = e;` `            ``break``;` `        ``}`   `        ``// Find the MEX of all subarray of` `        ``// length K by erasing arr[i]` `        ``// and inserting arr[i-K]` `        ``for` `(``int` `i = K; i < N; i++) {` `            ``s.remove(arr[i]);` `            ``s.add(arr[i - K]);`   `            ``// Store first element of set` `            ``for` `(``int` `e : s) {` `                ``if` `(e > mex)` `                    ``mex = e; ``// Updating mex` `                ``break``;` `            ``}` `        ``}`   `        ``// Print maximum MEX of all K` `        ``// length subarray` `        ``System.out.print(mex + ``" "``);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Given array` `        ``int` `arr[] = { ``6``, ``1``, ``3``, ``2``, ``4` `};`   `        ``// Given length of subarray` `        ``int` `K = ``3``;`   `        ``// Size of the array` `        ``int` `N = arr.length;`   `        ``// Function Call` `        ``maxMEX(arr, N, K);` `    ``}` `}`   `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 program for the above approach`   `# Function to return maximum MEX of` `# all K length subarray`     `def` `maxMEX(arr, N, K):`   `    ``# Stores element from 1 to N + 1` `    ``# is nor present in subarray` `    ``s ``=` `set``()`   `    ``# Store number 1 to N + 1 in set s` `    ``for` `i ``in` `range``(``1``, N ``+` `2``):` `        ``s.add(i)`   `    ``# Find the MEX of K length subarray` `    ``# starting from index 0` `    ``for` `i ``in` `range``(K):` `        ``s.remove(arr[i])`   `    ``mex ``=` `list``(s)[``0``]`   `    ``# Find the MEX of all subarray of` `    ``# length K by erasing arr[i]` `    ``# and inserting arr[i-K]` `    ``for` `i ``in` `range``(K, N):` `        ``s.remove(arr[i])`   `        ``s.add(arr[i ``-` `K])`   `        ``# Store first element of set` `        ``firstElem ``=` `list``(s)[``0``]`   `        ``# Updating mex` `        ``mex ``=` `max``(mex, firstElem)`   `    ``# Print maximum MEX of all K` `    ``# length subarray` `    ``print``(mex)`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# Given array` `    ``arr ``=` `[``3``, ``2``, ``1``, ``4``]`   `    ``# Size of the array` `    ``N ``=` `len``(arr)`   `    ``# Given length of subarray` `    ``K ``=` `2`   `    ``# Function Call` `    ``maxMEX(arr, N, K)`   `# This code is contributed by Shivam Singh`

## C#

 `// C# program for the` `// above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {`   `    ``// Function to return maximum` `    ``// MEX of all K length subarray` `    ``static` `void` `maxMEX(``int``[] arr, ``int` `N, ``int` `K)` `    ``{` `        ``// Stores element from` `        ``// 1 to N + 1 is nor` `        ``// present in subarray` `        ``HashSet<``int``> s = ``new` `HashSet<``int``>();`   `        ``// Store number 1 to` `        ``// N + 1 in set s` `        ``for` `(``int` `i = 1; i <= N + 1; i++)` `            ``s.Add(i);`   `        ``// Find the MEX of K length` `        ``// subarray starting from index 0` `        ``for` `(``int` `i = 0; i < K; i++)` `            ``s.Remove(arr[i]);`   `        ``List<``int``> v = ``new` `List<``int``>();` `        ``foreach``(``int` `i ``in` `s) { v.Add(i); }` `        ``int` `mex = v;`   `        ``// Find the MEX of all subarray of` `        ``// length K by erasing arr[i]` `        ``// and inserting arr[i-K]` `        ``for` `(``int` `i = K; i < N; i++) ` `        ``{` `            ``v.Remove(arr[i]);` `            ``v.Add(arr[i - K]);`   `            ``// Store first element` `            ``// of set` `            ``int` `firstElem = v;`   `            ``// Updating mex` `            ``mex = Math.Max(mex, firstElem);` `        ``}`   `        ``// Print maximum MEX of all K` `        ``// length subarray` `        ``Console.Write(mex - 2 + ``" "``);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``// Given array` `        ``int``[] arr = { 3, 2, 1, 4 };`   `        ``// Given length of subarray` `        ``int` `K = 2;`   `        ``// Size of the array` `        ``int` `N = arr.Length;`   `        ``// Function Call` `        ``maxMEX(arr, N, K);` `    ``}` `}`   `// This code is contributed by gauravrajput1`

Output

```3
```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :