 Open in App
Not now

# Maximum MEX from all subarrays of length K

• Difficulty Level : Hard
• Last Updated : 06 Jul, 2022

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 erase arr[i] to set and insert 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)

My Personal Notes arrow_drop_up
Related Articles