Open In App

Remove minimum elements such that no common elements exist in two arrays

Last Updated : 24 Feb, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

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:

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

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

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.


Next Article
2 Sum - Count pairs with given sum

N

nuclode
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox