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.
The MEX is the smallest positive integer that is not present in the array.
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++ program for the above approach #include <bits/stdc++.h> 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[0]);
// Function Call
maxMEX(arr, N, K);
return 0;
} |
// 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<Integer> 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 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# 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[0];
// 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[0];
// 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 |
<script> // JavaScript program for the above approach // Function to return maximum MEX of // all K length subarray function maxMEX( arr, N, K)
{ // Stores element from 1 to N + 1
// is nor present in subarray
let s = new Set();
// Store number 1 to N + 1 in set s
for (let i = 1; i <= N + 1; i++)
s.add(i);
// Find the MEX of K length subarray
// starting from index 0
for (let i = 0; i < K; i++)
s. delete (arr[i]);
let a = Array.from(s);
var mex = a[0];
// Find the MEX of all subarray of
// length K by erasing arr[i]
// and inserting arr[i-K]
for (let i = K; i < N; i++) {
s. delete (arr[i]);
s.add(arr[i - K]);
// Store first element of set
let ss = Array.from(s);
var firstElem = ss[ss.length-1];
// Updating mex
mex = Math.max(mex, firstElem);
}
// Print maximum MEX of all K
// length subarray
document.write( mex , ' ' );
} // Driver Code // Given array
let arr = [ 3, 2, 1, 4 ];
// Given length of subarray
let K = 2;
// Size of the array
let N = arr.length;
// Function Call
maxMEX(arr, N, K);
</script> |
3
Time Complexity: O(N * log N)
Auxiliary Space: O(N)