🏆 ยอดนิยม: dsa/remove minimum number elements no common element exist array

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.

Examples:

Input: arr[] = { 2, 3, 4, 5, 8 } , arr2[] = { 1, 2, 3, 4}
Output: 3
Explanation: remove all common elements, delete 2, 3, and 4 from either array.

Input : arr[] = { 1, 2, 3, 4 }, arr2[] = { 5, 6, 7 }
Output : 0
Explanation: There are no common elements between the arrays.

Try It Yourself

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. For each element that appears in both maps, adds the minimum frequency of that element in both arrays to a result.

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

Using Single Map - O(n+m) Time and O(n) Space

One map is enough because we only need to track elements from arr1 and check for their existence in arr2, avoiding redundant storage.

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.

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