Remove minimum elements such that no common elements exist in two arrays (original) (raw)

Last Updated : 24 Feb, 2025

Try it on GfG Practice

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
• Using Single Map - O(n+m) Time and O(n) Space

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:

C++ `

// 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& arr1, vector& 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 arr1 = { 1, 2, 3, 4 }; vector arr2 = { 2, 3, 4, 5, 8 };

cout << minRemove(arr1, arr2);

return 0;

}

Java

// 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));
}

}

Python

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#

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

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

`

**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 arr1 using a single map. Then, while iterating through arr2, we check for common elements and decrement their count, adding to the result. One map is enough because we only need to track elements from arr1 and check for their existence in arr2, avoiding redundant storage.

Below is the implementation of the above approach:

C++ `

// 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& arr1, vector& 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 arr1 = {1, 2, 3, 4}; vector arr2 = {2, 3, 4, 5, 8};

cout << minRemove(arr1, arr2);

return 0;

}

Java

// 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));
}

}

Python

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#

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

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

`

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