Skip to content
Related Articles
Maximum MEX from all subarrays of length K
• Difficulty Level : Medium
• Last Updated : 19 May, 2021

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``        ``TreeSet s = ``new` `TreeSet<>();` `        ``// Store number 1 to``        ``// N + 1 in set s``          ``for``(``int` `l=``1``;l<=N+``1``;l++)   ``          ``s.add(l);``          ``// i and j point to the start of the array``          ``// i.e index 0``          ``int` `i=``0``;``          ``int` `j=``0``;``          ` `          ``int` `mex = ``0``;``          ``// mex variable which stores the mex for``          ``// generated subArrays``          ``int` `maxMex = Integer.MIN_VALUE;``          ``//maxMex contains the maximum mex value for all subArrays``          ` `          ``while``(j < N)``        ``{``          ``if``(s.contains(arr[j]))``             ``s.remove(arr[j]);``          ``int` `windowSize = j-i+``1``;``          ``// window size at any instant is given by j-i+1;``          ``if``(windowSize < k)``             ``j++;``             ``// here, windowSize < k , i.e we haven't reached the first``             ``// window of size k yet.. so we increment j;``          ``else` `if``(windowSize == k)``          ``{``            ``//here , windowSize equals k, we are to get an answer everytime``            ``// we reached the windowSize of k , first element of the set has``            ``// mex for this subArray;``            ``mex = s.pollFirst();``            ``// set.pollFirst() function removes the firstElement in the treeset;``            ``maxMex = Math.max(maxMex,mex);``            ` `            ``// before sliding the window , we need to undo the calculations``            ``// done at the starting point , i.e i;``            ``s.add(arr[i]);``            ``i++;``            ``j++;``            ``// sliding the window by 1 each in i and j , so as to maintain``            ``// the windowSize k;``          ``}``        ``}``        ``System.out.println(maxMex);``    ``}` `    ``// 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`

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up