Related Articles

# Rearrange array elements to maximize the sum of MEX of all prefix arrays

• Last Updated : 17 Jul, 2021

Given an array arr[] of size N, the task is to rearrange the array elements such that the sum of MEX of all prefix arrays is the maximum possible.

Note: MEX of a sequence is the minimum non-negative number not present in the sequence.

Examples:

Input: arr[] = {2, 0, 1}
Output: 0, 1, 2
Explanation:
Sum of MEX of all prefix arrays of all possible permutations of the given array:
arr[] = {0, 1, 2}, Mex(0) + Mex(0, 1) + Mex(0, 1, 2) = 1 + 2 + 3 = 6
arr[] = {1, 0, 2}, Mex(1) + Mex(1, 0) + Mex(1, 0, 2) = 0 + 2 + 3 = 5
arr[] = {2, 0, 1}, Mex(2) + Mex(2, 0) + Mex(2, 0, 1) = 0 + 1 + 3 = 4
arr[] = {0, 2, 1}, Mex(0) + Mex(0, 2) + Mex(0, 2, 1) = 1 + 1 + 3 = 5
arr[] = {1, 2, 0}, Mex(1) + Mex(1, 2) + Mex(1, 2, 0) = 0 + 0 + 3 = 3
arr[] = {2, 1, 0}, Mex(2) + Mex(2, 1) + Mex(2, 1, 0) = 0 + 0 + 3 = 3
Hence, the maximum sum possible is 6.

Input: arr[] = {1, 0, 0}
Output: 0, 1, 0
Explanation:
Sum of MEX of all prefix arrays of all possible permutations of the given array:
arr[]={1, 0, 0}, Mex(1) + Mex(1, 0) + Mex(1, 0, 0) = 0 + 2 + 2 = 4
arr[]={0, 1, 0}, Mex(0) + Mex(0, 1) + Mex(0, 1, 0) = 1 + 2 + 2 = 5
arr[]={0, 0, 1}, Mex(0) + Mex(0, 0) + Mex(0, 0, 1) = 1 + 1 + 2 = 4
Hence, the maximum value is 5 for the arrangement, arr[]={0, 1, 0}.

Naive Approach: The simplest approach is to generate all possible permutations of the given array arr[] and then for each permutation, find the value of MEX of all the prefix arrays, while keeping track of the overall maximum value. After iterating over all possible permutations, print the permutation having the largest value.

Time Complexity: O(N2 * N!)
Auxiliary Space: O(N)

Efficient Approach: The optimal idea is based on the observation that the sum of MEX of prefix arrays will be maximum when all the distinct elements are arranged in increasing order and the duplicates are present at the end of the array.
Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum sum of``// MEX of prefix arrays for any``// arrangement of the given array``void` `maximumMex(``int` `arr[], ``int` `N)``{` `    ``// Stores the final arrangement``    ``vector<``int``> ans;` `    ``// Sort the array in increasing order``    ``sort(arr, arr + N);` `    ``// Iterate over the array arr[]``    ``for` `(``int` `i = 0; i < N; i++) {``        ``if` `(i == 0 || arr[i] != arr[i - 1])``            ``ans.push_back(arr[i]);``    ``}` `    ``// Iterate over the array, arr[]``    ``// and push the remaining occurrences``    ``// of the elements into ans[]``    ``for` `(``int` `i = 0; i < N; i++) {``        ``if` `(i > 0 && arr[i] == arr[i - 1])``            ``ans.push_back(arr[i]);``    ``}` `    ``// Print the array, ans[]``    ``for` `(``int` `i = 0; i < N; i++)``        ``cout << ans[i] << ``" "``;``}` `// Driver Code``int` `main()``{` `    ``// Given array``    ``int` `arr[] = { 1, 0, 0 };` `    ``// Store the size of the array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function Call``    ``maximumMex(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.Arrays;  ` `class` `GFG{``    ` `// Function to find the maximum sum of``// MEX of prefix arrays for any``// arrangement of the given array``static` `void` `maximumMex(``int` `arr[], ``int` `N)``{``    ` `    ``// Stores the final arrangement``    ``int` `ans[] = ``new` `int``[``2` `* N];` `    ``// Sort the array in increasing order``    ``Arrays.sort(ans);``    ``int` `j = ``0``;``    ` `    ``// Iterate over the array arr[]``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ``if` `(i == ``0` `|| arr[i] != arr[i - ``1``])``        ``{``            ``j += ``1``;``            ``ans[j] = arr[i];``        ``}``    ``}` `    ``// Iterate over the array, arr[]``    ``// and push the remaining occurrences``    ``// of the elements into ans[]``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ``if` `(i > ``0` `&& arr[i] == arr[i - ``1``])``        ``{``            ``j += ``1``;``            ``ans[j] = arr[i];``        ``}``    ``}` `    ``// Print the array, ans[]``    ``for``(``int` `i = ``0``; i < N; i++)``        ``System.out.print(ans[i] + ``" "``);``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ` `    ``// Given array``    ``int` `arr[] = { ``1``, ``0``, ``0` `};` `    ``// Store the size of the array``    ``int` `N = arr.length;` `    ``// Function Call``    ``maximumMex(arr, N);``}``}` `// This code is contributed by AnkThon`

## Python3

 `# Python3 program for the above approach` `# Function to find the maximum sum of``# MEX of prefix arrays for any``# arrangement of the given array``def` `maximumMex(arr, N):` `    ``# Stores the final arrangement``    ``ans ``=` `[]` `    ``# Sort the array in increasing order``    ``arr ``=` `sorted``(arr)` `    ``# Iterate over the array arr[]``    ``for` `i ``in` `range``(N):``        ``if` `(i ``=``=` `0` `or` `arr[i] !``=` `arr[i ``-` `1``]):``            ``ans.append(arr[i])` `    ``# Iterate over the array, arr[]``    ``# and push the remaining occurrences``    ``# of the elements into ans[]``    ``for` `i ``in` `range``(N):``        ``if` `(i > ``0` `and` `arr[i] ``=``=` `arr[i ``-` `1``]):``            ``ans.append(arr[i])` `    ``# Prthe array, ans[]``    ``for` `i ``in` `range``(N):``        ``print``(ans[i], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given array``    ``arr ``=` `[``1``, ``0``, ``0` `]` `    ``# Store the size of the array``    ``N ``=` `len``(arr)` `    ``# Function Call``    ``maximumMex(arr, N)` `# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `// Function to find the maximum sum of``// MEX of prefix arrays for any``// arrangement of the given array``static` `void` `maximumMex(``int` `[]arr, ``int` `N)``{``    ` `    ``// Stores the final arrangement``    ``int` `[]ans = ``new` `int``[2 * N];` `    ``// Sort the array in increasing order``    ``Array.Sort(ans);``    ``int` `j = 0;``    ` `    ``// Iterate over the array arr[]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``if` `(i == 0 || arr[i] != arr[i - 1])``        ``{``            ``j += 1;``            ``ans[j] = arr[i];``        ``}``    ``}` `    ``// Iterate over the array, arr[]``    ``// and push the remaining occurrences``    ``// of the elements into ans[]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``if` `(i > 0 && arr[i] == arr[i - 1])``        ``{``            ``j += 1;``            ``ans[j] = arr[i];``        ``}``    ``}` `    ``// Print the array, ans[]``    ``for``(``int` `i = 0; i < N; i++)``        ``Console.Write(ans[i] + ``" "``);``}` `// Driver Code``public` `static` `void` `Main (``string``[] args)``{``    ` `    ``// Given array``    ``int` `[]arr = { 1, 0, 0 };` `    ``// Store the size of the array``    ``int` `N = arr.Length;` `    ``// Function Call``    ``maximumMex(arr, N);``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``
Output:
`0 1 0`

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up