Maximize MEX by adding or subtracting K from Array elements
Last Updated :
31 Oct, 2023
Given an arr[] of size N and an integer, K, the task is to find the maximum possible value of MEX by adding or subtracting K any number of times from the array elements.
MEX is the minimum non-negative integer that is not present in the array
Examples:
Input: arr[]={1, 3, 4}, K = 2
Output: 2
Explanation: After subtracting K from arr[2] twice,
the final array will be {1, 3, 0}.
So the MEX is 2 which is maximum possible answer.
Input: arr[] = {0, 1, 2, 1, 3}, K = 3
Output: 5
Explanation: After adding K to arr[1], the final array will be {0, 4, 2, 1, 3}.
So the MEX is 5 which is maximum possible answer.
Approach: Follow the below idea to solve the problem:
The maximum MEX which can be achieved from an array of size N is N. For this, we need to have all the elements from 0 to N – 1 by doing some operations. If there is a number that is not achievable by doing some operation then this is the answer.
We can generate a number x from a number p by doing addition or subtraction if both remainders are same by diving it with K [i.e., the difference between them is divisible by K].
Follow the steps to solve the problem:
- Create a map that stores the frequency of the remainder of all the elements of the array.
- Traverse from 0 to N-1 and check if there is a need to generate the number x then x % K must be present in the map.
- If it is present in the map then decrease the frequency of x % K and continue.
- Else, return the number as the answer.
Below is the implementation for the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int mex( int arr[], int n, int K)
{
unordered_map< int , int > mp;
for ( int i = 0; i < n; i++) {
mp[arr[i] % K]++;
}
for ( int i = 0; i < n; i++) {
if (mp.find(i % K) == mp.end()) {
return i;
}
mp[i % K]--;
if (mp[i % K] == 0)
mp.erase(i % K);
}
return n;
}
int main()
{
int arr[] = { 0, 1, 2, 1, 3 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = 3;
cout << mex(arr, N, K) << endl;
return 0;
}
|
Java
import java.io.*;
import java.util.*;
import java.util.HashMap;
class GFG {
public static int mex( int [] arr, int n, int K)
{
Map<Integer, Integer> mp
= new HashMap<Integer, Integer>();
for ( int v : arr) {
mp.putIfAbsent(v % K, 0 );
mp.put(v % K, mp.get(v % K) + 1 );
}
for ( int i = 0 ; i < n; i++) {
if (!mp.containsKey(i % K)) {
return i;
}
mp.put(i % K, mp.get(i % K) - 1 );
if (mp.get(i % K) <= 0 ) {
mp.remove(i % K);
}
}
return n;
}
public static void main(String[] args)
{
int arr[] = { 0 , 1 , 2 , 1 , 3 };
int N = arr.length;
int K = 3 ;
System.out.println(mex(arr, N, K));
}
}
|
Python3
from collections import defaultdict
def mex(arr, n, K) :
mp = defaultdict( lambda : 0 )
for i in range (n):
mp[arr[i] % K] + = 1 ;
for i in range (n):
if ((i % K) not in mp) :
return i
mp[i % K] - = 1
if (mp[i % K] = = 0 ) :
del mp[i % K]
return n
if __name__ = = "__main__" :
arr = [ 0 , 1 , 2 , 1 , 3 ]
N = len (arr)
K = 3
print (mex(arr, N, K))
|
C#
using System;
using System.Collections.Generic;
public class GFG {
public static int mex( int [] arr, int n, int K)
{
Dictionary< int , int > mp
= new Dictionary< int , int >();
for ( int i = 0; i < n; i++) {
mp.Add(i, 0);
}
for ( int i = 0; i < n; i++) {
if (mp.ContainsKey(arr[i] % K))
mp[mp[arr[i] % K]]=
mp[arr[i] % K] + 1;
else
mp.Add(mp[arr[i] % K],
1);
}
for ( int i = 0; i < n; i++) {
if (mp[i%K] > 1 ){
return i;
}
if (mp.ContainsKey(arr[i] % K))
mp[mp[arr[i] % K]]=
mp[arr[i] % K] - 1;
if (mp.ContainsKey(i % K) && mp[i % K] <= 0)
mp[mp[arr[i] % K]]=
0;
}
return n;
}
public static void Main(String[] args)
{
int []arr = { 0, 1, 2, 1, 3 };
int N = arr.Length;
int K = 3;
Console.WriteLine(mex(arr, N, K));
}
}
|
Javascript
<script>
function mex(arr,n,K)
{
let mp= new Map();
for (let i = 0; i < n; i++) {
mp[arr[i] % K]++;
}
for (let i = 0; i < n; i++) {
if (mp.has(i % K)) {
return i;
}
mp[i % K]--;
if (mp[i % K] == 0)
mp. delete (i % K);
}
return n;
}
let arr = [ 0, 1, 2, 1, 3 ];
let N = arr.length;
let K = 3;
document.write(mex(arr, N, K));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...