Find the Prefix-MEX Array for given Array

Given an array A[] of N elements, the task is to create a Prefix-MEX array for this given array. Prefix-MEX array B[] of an array A[] is created such that MEX of A[0] till A[i] is B[i]. 

MEX of an array refers to the smallest missing non-negative integer of the array.

Examples:

Input: A[] = {1, 0, 2, 4, 3}
Output: 0 2 3 3 5
Explanation: In the array A, elements 
Till 1st index, elements are [1] and mex till 1st index is 0.
Till 2nd index, elements are [1, 0] and mex till 2nd index is 2.
Till 3rd index, elements are [ 1, 0, 2] and mex till 3rd index is 3.
Till 4th index, elements are [ 1, 0, 2, 4] and mex till 4th index is 3.
Till 5th index, elements are [ 1, 0, 2, 4, 3] and mex till 5th index is 5.
So our final array B would be [0, 2, 3, 3, 5].

Input: A[] = [ 1, 2, 0 ]
Output: [ 0, 0, 3 ]
Explanation: In the array A, elements 
Till 1st index, elements are [1] and mex till 1st index is 0.
Till 2nd index, elements are [1, 2] and mex till 2nd index is 0.
Till 3rd index, elements are [ 1, 2, 0] and mex till 3rd index is 3.
So our final array B would be [0, 0, 3].

Naive Approach: The simplest way to solve the problem is:

For each element at i^th (0 ≤ i < N)index of the array A[], find MEX from 0 to i and store it at B[i].

Follow the steps mentioned below to implement the idea:

• Iterate over the array from i = 0 to N-1:
  • For every i^th index in array A[]: 
    • Run a for loop to find the MEX of index 0 till i.
    • Then store this MEX at index i in the resultant array B[i].
• Return the resultant array B[] at the end.

Time Complexity: O(N²)
Auxiliary Space: O(N)

Efficient Approach: This approach is based on the usage of Set data structure.

A set stores data in sorted order. We can take advantage of that and store all the non-negative integers till the maximum value of the array. Then traverse through each array element and remove the visited data from set. The smallest remaining element will be the MEX for that index.

Follow the steps below to implement the idea:

• Find the maximum element of the array A[].
• Create a set and store the numbers from 0 to the maximum element in the set.
• Traverse through the array from i = 0 to N-1: 
  • For each element, erase that element from the set.
  • Now find the smallest element remaining in the set.
  • This is the prefix MEX for the i^th element. Store this value in the resultant array.
• Return the resultant array as the required answer.

Below is the implementation of the above approach. 

C++

// C++ code to implement the approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the prefix MEX
// for each array element
vector<int> Prefix_Mex(vector<int>& A, int n)
{
    // Maximum element in vector A
    int mx_element = *max_element(A.begin(), A.end());

    // Store all number from 0
    // to maximum element + 1 in a set
    set<int> s;
    for (int i = 0; i <= mx_element + 1; i++) {
        s.insert(i);
    }

    // Loop to calculate Mex for each index
    vector<int> B(n);
    for (int i = 0; i < n; i++) {

        // Checking if A[i] is present in set
        auto it = s.find(A[i]);

        // If present then we erase that element
        if (it != s.end())
            s.erase(it);

        // Store the first element of set
        // in vector B as Mex of prefix vector
        B[i] = *s.begin();
    }

    // Return the vector B
    return B;
}

// Driver code
int main()
{

    vector<int> A = { 1, 0, 2, 4, 3 };
    int N = A.size();

    // Function call
    vector<int> B = Prefix_Mex(A, N);

    // Print the prefix MEX array
    for (int i = 0; i < N; i++) {
        cout << B[i] << " ";
    }
    return 0;
}

Java

// Java code to implement the approach
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.stream.Collectors;

class GFG{

// Function to find the prefix MEX
// for each array element
static int[] Prefix_Mex(int[] A, int n)
{

    // Maximum element in vector A
    int mx_element = Arrays.stream(A).max().getAsInt();

    // Store all number from 0
    // to maximum element + 1 in a set
    LinkedHashSet<Integer> s = new LinkedHashSet<>();
    for (int i = 0; i <= mx_element + 1; i++) {
        s.add(i);
    }

    // Loop to calculate Mex for each index
    int []B = new int[n];
    for (int i = 0; i < n; i++) {

        // Checking if A[i] is present in set
        // If present then we erase that element
        if (s.contains(A[i]))
            s.remove(A[i]);

        // Store the first element of set
        // in vector B as Mex of prefix vector
        B[i] = s.stream().collect(Collectors.toList()).get(0);
    }

    // Return the vector B
    return B;
}

// Driver code
public static void main(String[] args)
{

    int[] A = { 1, 0, 2, 4, 3 };
    int N = A.length;

    // Function call
    int[] B = Prefix_Mex(A, N);

    // Print the prefix MEX array
    for (int i = 0; i < N; i++) {
        System.out.print(B[i]+ " ");
    }
}
}

// This code is contributed by shikhasingrajput

Python3

# Python code to implement the approach

# Function to find the prefix MEX
# for each array element
def Prefix_Mex(A, n):
    # Maximum element in vector A
    mx_element = max(A)
    # Store all number from 0
    # to maximum element + 1 in a set
    s = {}
    for i in range(mx_element+2):
        s[i] = True

    # Loop to calculate Mex for each index
    B = [0]*n
    for i in range(n):
        # Checking if A[i] is present in set
        # If present then we erase that element
        if A[i] in s.keys():
            del s[A[i]]
        # Store the first element of set
        # in vector B as Mex of prefix vector
        B[i] = int(list(s.keys())[0])
        # Return the list B
    return B


# Driver code
if __name__ == "__main__":
    A = [1, 0, 2, 4, 3]
    N = len(A)

    # Function call
    B = Prefix_Mex(A, N)

    # Print the prefix MEX array
    for i in range(N):
        print(B[i], end=" ")

# This code is contributed by Rohit Pradhan

C#

// C# code to implement the approach
using System;
using System.Collections.Generic;
using System.Linq;
public class GFG{

// Function to find the prefix MEX
// for each array element
static int[] Prefix_Mex(int[] A, int n)
{

    // Maximum element in vector A
    int mx_element =A.Max();

    // Store all number from 0
    // to maximum element + 1 in a set
    HashSet<int> s = new HashSet<int>();
    for (int i = 0; i <= mx_element + 1; i++) {
        s.Add(i);
    }

    // Loop to calculate Mex for each index
    int []B = new int[n];
    for (int i = 0; i < n; i++) {

        // Checking if A[i] is present in set
        // If present then we erase that element
        if (s.Contains(A[i]))
            s.Remove(A[i]);

        // Store the first element of set
        // in vector B as Mex of prefix vector
        B[i] = s.FirstOrDefault();
    }

    // Return the vector B
    return B;
}

// Driver code
public static void Main(String[] args)
{

    int[] A = { 1, 0, 2, 4, 3 };
    int N = A.Length;

    // Function call
    int[] B = Prefix_Mex(A, N);

    // Print the prefix MEX array
    for (int i = 0; i < N; i++) {
        Console.Write(B[i]+ " ");
    }
}
}

// This code is contributed by shikhasingrajput

Javascript

<script>
        // JavaScript code to implement the approach

        // Function to find the prefix MEX
        // for each array element
        const Prefix_Mex = (A, n) => {
            // Maximum element in vector A
            let mx_element = Math.max(...A);

            // Store all number from 0
            // to maximum element + 1 in a set
            let s = new Set();

            for (let i = 0; i <= mx_element + 1; i++) {
                s.add(i);
            }

            // Loop to calculate Mex for each index
            let B = new Array(n).fill(0);
            for (let i = 0; i < n; i++) {

                // Checking if A[i] is present in set
                let it = s.has(A[i]);

                // If present then we erase that element
                if (it) s.delete(A[i]);


                // Store the first element of set
                // in vector B as Mex of prefix vector
                B[i] = s.values().next().value;
            }

            // Return the vector B
            return B;
        }

        // Driver code

        let A = [1, 0, 2, 4, 3];
        let N = A.length;

        // Function call
        let B = Prefix_Mex(A, N);

        // Print the prefix MEX array
        for (let i = 0; i < N; i++) {
            document.write(`${B[i]} `);
        }

        // This code is contributed by rakeshsahni

    </script>

Output

0 2 3 3 5 

Time Complexity: O(N * log N )

• O(N) for iterating the vector, and 
• O(log N) for inserting and deleting the element from the set.

Auxiliary Space: O(N)

Efficient Approach 2: This approach is based on using an array and a pointer to keep track of the MEX.

Follow these steps mentioned below to implement this idea:

• Find the maximum element of the array A[].
• Create a boolean array of size equal to the maximum element + 1, B[] with all values initialised as 0.
• Create a variable to track the current MEX.
• Traverse through the A[] from i = 0 to N-1:
  • For each element, set the value in B[] at index equal to the value of the element at i in A[] to true.
  • Update the current MEX by increasing the variable until value in B[] at MEX is true.
  • Store this value in the resultant array.
• Return the resultant array as the required answer.

Below is the implementation of the above approach.

C++

#include <bits/stdc++.h>
using namespace std;

// Function to compute Prefix Mex
vector<int> Prefix_Mex(vector<int>& A, int n) {
    // Create a boolean vector to track the presence of numbers
    vector<bool> b(n+1);

    // Initialize mex (minimum excluded value) to 0
    int mex = 0;

    // Result vector to store the Prefix Mex values
    vector<int> result(n);

    // Loop through the input vector A
    for (int i = 0; i < n; i++) {
        // Mark the current element as present
        b[A[i]] = true;

        // Update mex until a non-present value is found
        while (b[mex] == true) {
            mex++;
        }

        // Store the current mex value in the result vector
        result[i] = mex;
    }

    // Return the result vector
    return result;
}

int main()
{
    // Input vector
    vector<int> A = { 2, 1, 0, 3, 5, 4 };

    // Get the size of the input vector
    int n = A.size();

    // Compute the Prefix Mex values using the defined function
    vector<int> result = Prefix_Mex(A, n);

    // Print the Prefix Mex values
    for (int i = 0; i < n; i++) {
        cout << result[i] << " ";
    }

    // Return 0 to indicate successful execution
    return 0;
}

Java

import java.util.Arrays;

public class Main {
    // Function to compute Prefix Mex
    static int[] prefixMex(int[] A, int n) {
        // Create a boolean array to track the presence of numbers
        boolean[] b = new boolean[n+1];

        // Initialize mex (minimum excluded value) to 0
        int mex = 0;

        // Result array to store the Prefix Mex values
        int[] result = new int[n];

        // Loop through the input array A
        for (int i = 0; i < n; i++) {
            // Mark the current element as present
            b[A[i]] = true;

            // Update mex until a non-present value is found
            while (b[mex]) {
                mex++;
            }

            // Store the current mex value in the result array
            result[i] = mex;
        }

        // Return the result array
        return result;
    }

    public static void main(String[] args) {
        // Input array
        int[] A = {2, 1, 0, 3, 5, 4};

        // Get the size of the input array
        int n = A.length;

        // Compute the Prefix Mex values using the defined function
        int[] result = prefixMex(A, n);

        // Print the Prefix Mex values
        for (int i = 0; i < n; i++) {
            System.out.print(result[i] + " ");
        }
    }
}

Python3

def prefix_mex(A, n):
    # Create a boolean list to track the presence of numbers
    b = [False] * (n+1)

    # Initialize mex (minimum excluded value) to 0
    mex = 0

    # Result list to store the Prefix Mex values
    result = [0] * n

    # Loop through the input list A
    for i in range(n):
        # Mark the current element as present
        b[A[i]] = True

        # Update mex until a non-present value is found
        while b[mex]:
            mex += 1

        # Store the current mex value in the result list
        result[i] = mex

    # Return the result list
    return result

# Main
A = [2, 1, 0, 3, 5, 4]
n = len(A)

result = prefix_mex(A, n)

for i in result:
    print(i, end=' ')

C#

using System;

class Program
{
    // Function to compute Prefix Mex
    static int[] PrefixMex(int[] A, int n)
    {
        // Create a boolean array to track the presence of numbers
        bool[] b = new bool[n+1];

        // Initialize mex (minimum excluded value) to 0
        int mex = 0;

        // Result array to store the Prefix Mex values
        int[] result = new int[n];

        // Loop through the input array A
        for (int i = 0; i < n; i++)
        {
            // Mark the current element as present
            b[A[i]] = true;

            // Update mex until a non-present value is found
            while (b[mex])
            {
                mex++;
            }

            // Store the current mex value in the result array
            result[i] = mex;
        }

        // Return the result array
        return result;
    }

    static void Main()
    {
        // Input array
        int[] A = {2, 1, 0, 3, 5, 4};

        // Get the size of the input array
        int n = A.Length;

        // Compute the Prefix Mex values using the defined function
        int[] result = PrefixMex(A, n);

        // Print the Prefix Mex values
        foreach (int i in result)
        {
            Console.Write(i + " ");
        }
    }
}

Javascript

// Function to compute Prefix Mex
function prefixMex(A, n) {
    // Create a boolean array to track the presence of numbers
    let b = Array(n+1).fill(false);

    // Initialize mex (minimum excluded value) to 0
    let mex = 0;

    // Result array to store the Prefix Mex values
    let result = Array(n).fill(0);

    // Loop through the input array A
    for (let i = 0; i < n; i++) {
        // Mark the current element as present
        b[A[i]] = true;

        // Update mex until a non-present value is found
        while (b[mex]) {
            mex++;
        }

        // Store the current mex value in the result array
        result[i] = mex;
    }

    // Return the result array
    return result;
}

// Main
let A = [2, 1, 0, 3, 5, 4];
let n = A.length;

let result = prefixMex(A, n);

// Print the Prefix Mex values
console.log(result.join(' '));

Output

0 0 3 4 4 6 

Time Complexity: O(N)

• O(N) for iterating the vector.
• O(N) for updating the MEX. Important thing to note is that the inner while loop can run only N times independent of the outer for loop.

Space Complexity: O(N)