Remove minimum elements such that no common elements exist in two arrays
Given two arrays arr1[] and arr2[] consisting of n and m elements respectively. The task is to find the minimum number of elements to remove from each array such that intersection of both arrays becomes empty and both arrays become mutually exclusive.
Examples:
Input: arr[] = { 1, 2, 3, 4}, arr2[] = { 2, 3, 4, 5, 8 }
Output: 3
Explanation: We need to remove 2, 3 and 4 from any array.
Input: arr[] = { 4, 2, 4, 4}, arr2[] = { 4, 3 }
Output: 1
Explanation: We need to remove 4 from arr2[]
Input : arr[] = { 1, 2, 3, 4 }, arr2[] = { 5, 6, 7 }
Output : 0
Explanation: There is no common element in both.
Table of Content
Using Two Maps - O(n+m) Time and O(n+m) Space
The idea is to use Hashing We first count the frequency of each element in both arrays using two map data structures. After counting, iterates through all elements in the first map (countA). For each element that appears in both maps, adds the minimum frequency of that element in both arrays to a result variable (res). This sum represents the minimum number of removals required to remove all common elements between the two arrays.
Below is the implementation of the above approach:
// CPP program to find minimum element to remove so no common element
// exist in both array
#include <bits/stdc++.h>
using namespace std;
// To find no elements to remove
// so no common element exist
int minRemove(vector<int>& arr1, vector<int>& arr2)
{
// To store count of array elements
unordered_map<int, int> countA, countB;
// Count elements of arr1
for (int i = 0; i < arr1.size(); i++)
countA[arr1[i]]++;
// Count elements of arr2
for (int i = 0; i < arr2.size(); i++)
countB[arr2[i]]++;
// Traverse through all common elements, and
// pick minimum occurrence from two arrays
int res = 0;
for (auto x : countA)
if (countB.find(x.first) != countB.end())
res += min(x.second, countB[x.first]);
// To return count of minimum elements
return res;
}
int main()
{
vector<int> arr1 = { 1, 2, 3, 4 };
vector<int> arr2 = { 2, 3, 4, 5, 8 };
cout << minRemove(arr1, arr2);
return 0;
}
// Java Code to Remove minimum number of elements
// such that no common element exist in both array
import java.util.HashMap;
class GfG {
static int minRemove(int[] arr1, int[] arr2) {
HashMap<Integer, Integer> countA = new HashMap<>();
HashMap<Integer, Integer> countB = new HashMap<>();
int res = 0;
// Count elements of arr1
for (int num : arr1) {
countA.put(num, countA.getOrDefault(num, 0) + 1);
}
// Count elements of arr2
for (int num : arr2) {
countB.put(num, countB.getOrDefault(num, 0) + 1);
}
// Traverse through all common elements, and pick minimum
// occurrence from two arrays
for (int key : countA.keySet()) {
if (countB.containsKey(key)) {
res += Math.min(countA.get(key), countB.get(key));
}
}
return res;
}
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4};
int[] arr2 = {2, 3, 4, 5, 8};
System.out.println(minRemove(arr1, arr2));
}
}
# Python3 program to find minimum element to remove so no common
# element exist in both array
from collections import Counter
def minRemove(arr1, arr2):
countA = Counter(arr1)
countB = Counter(arr2)
res = 0
# Traverse through all common elements, and pick minimum
# occurrence from two arrays
for key in countA:
if key in countB:
res += min(countA[key], countB[key])
return res
arr1 = [1, 2, 3, 4]
arr2 = [2, 3, 4, 5, 8]
print(minRemove(arr1, arr2))
// C# Code to Remove minimum number of elements
// such that no common element exist in both array
using System;
using System.Collections.Generic;
class GfG
{
static int MinRemove(int[] arr1, int[] arr2)
{
Dictionary<int, int> countA = new Dictionary<int, int>();
Dictionary<int, int> countB = new Dictionary<int, int>();
int res = 0;
// Count elements of arr1
foreach (int num in arr1)
{
if (countA.ContainsKey(num))
countA[num]++;
else
countA[num] = 1;
}
// Count elements of arr2
foreach (int num in arr2)
{
if (countB.ContainsKey(num))
countB[num]++;
else
countB[num] = 1;
}
// Traverse through all common elements, and pick minimum
// occurrence from two arrays
foreach (var key in countA.Keys)
{
if (countB.ContainsKey(key))
{
res += Math.Min(countA[key], countB[key]);
}
}
return res;
}
static void Main(string[] args)
{
int[] arr1 = { 1, 2, 3, 4 };
int[] arr2 = { 2, 3, 4, 5, 8 };
Console.WriteLine(MinRemove(arr1, arr2));
}
}
// Javascript program to find minimum element to remove
// so no common element exist in both array
function minRemove(arr1, arr2) {
let countA = {};
let countB = {};
let res = 0;
// Count elements of arr1
for (let num of arr1) {
countA[num] = (countA[num] || 0) + 1;
}
// Count elements of arr2
for (let num of arr2) {
countB[num] = (countB[num] || 0) + 1;
}
// Traverse through all common elements, and pick minimum
// occurrence from two arrays
for (let key in countA) {
if (countB.hasOwnProperty(key)) {
res += Math.min(countA[key], countB[key]);
}
}
return res;
}
const arr1 = [1, 2, 3, 4];
const arr2 = [2, 3, 4, 5, 8];
console.log(minRemove(arr1, arr2));
Output
3
Time Complexity: O(n+m), where m and n are the length of arr1 and arr2 respectively
Auxiliary Space: O(n+m), For storing the frequency in map for both the arrays
Using Single Map - O(n+m) Time and O(n) Space
The idea is to count occurrences of elements from
arr1using a single map. Then, while iterating througharr2, we check for common elements and decrement their count, adding to the result. One map is enough because we only need to track elements fromarr1and check for their existence inarr2, avoiding redundant storage.
Below is the implementation of the above approach:
// CPP program to find minimum elements to remove
// so no common element exists in both arrays using a single map
#include <bits/stdc++.h>
using namespace std;
int minRemove(vector<int>& arr1, vector<int>& arr2) {
unordered_map<int, int> count;
// Count elements of arr1
for (int x : arr1) {
count[x] += 1;
}
int res = 0;
// Count elements of arr2 and check common elements
for (int x : arr2) {
if (count.find(x) != count.end() && count[x] > 0) {
count[x]--;
res++;
}
}
return res;
}
int main() {
vector<int> arr1 = {1, 2, 3, 4};
vector<int> arr2 = {2, 3, 4, 5, 8};
cout << minRemove(arr1, arr2);
return 0;
}
// Java program to find minimum elements to remove
// so no common element exists in both arrays using a single map
import java.util.HashMap;
class GfG {
static int minRemove(int[] arr1, int[] arr2) {
HashMap<Integer, Integer> count = new HashMap<>();
int res = 0;
// Count elements of arr1
for (int num : arr1) {
count.put(num, count.getOrDefault(num, 0) + 1);
}
// Count elements of arr2 and check common elements
for (int num : arr2) {
if (count.containsKey(num) && count.get(num) > 0) {
count.put(num, count.get(num) - 1);
res++;
}
}
return res;
}
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4};
int[] arr2 = {2, 3, 4, 5, 8};
System.out.println(minRemove(arr1, arr2));
}
}
# Python3 program to find minimum elements to remove
# so no common element exists in both arrays using a single map
from collections import Counter
def minRemove(arr1, arr2):
count = Counter(arr1)
res = 0
# Count elements of arr2 and check common elements
for num in arr2:
if count[num] > 0:
count[num] -= 1
res += 1
return res
arr1 = [1, 2, 3, 4]
arr2 = [2, 3, 4, 5, 8]
print(minRemove(arr1, arr2))
// C# program to find minimum elements to remove
// so no common element exists in both arrays using a single map
using System;
using System.Collections.Generic;
class GfG
{
static int MinRemove(int[] arr1, int[] arr2)
{
Dictionary<int, int> count = new Dictionary<int, int>();
int res = 0;
// Count elements of arr1
foreach (int num in arr1)
{
if (count.ContainsKey(num))
count[num]++;
else
count[num] = 1;
}
// Count elements of arr2 and check common elements
foreach (int num in arr2)
{
if (count.ContainsKey(num) && count[num] > 0)
{
count[num]--;
res++;
}
}
return res;
}
static void Main(string[] args)
{
int[] arr1 = { 1, 2, 3, 4 };
int[] arr2 = { 2, 3, 4, 5, 8 };
Console.WriteLine(MinRemove(arr1, arr2));
}
}
// Javascript program to find minimum elements to remove
// so no common element exists in both arrays using a single map
function minRemove(arr1, arr2) {
let count = {};
let res = 0;
// Count elements of arr1
for (let num of arr1) {
count[num] = (count[num] || 0) + 1;
}
// Count elements of arr2 and check common elements
for (let num of arr2) {
if (count[num] && count[num] > 0) {
count[num]--;
res++;
}
}
return res;
}
const arr1 = [1, 2, 3, 4];
const arr2 = [2, 3, 4, 5, 8];
console.log(minRemove(arr1, arr2));
Output
3
Time Complexity: O(n+m), where m and n are the length of arr1 and arr2 respectively
Auxiliary Space: O(n), as we use a map to store elements of arr1.
