Maximum MEX from all subarrays of length K

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 * N²)
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 <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

// 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

# 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[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

Javascript

<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>

Output

3 

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