Given two sets of integers as two arrays of size m and n. Find count of minimum numbers that should be removed from the sets so that both set become disjoint or don’t contains any elements in common. We can remove elements from any set. We need to find minimum total elements to be removed.
Examples :
Input : set1[] = {20, 21, 22}
set2[] = {22, 23, 24, 25}
Output : 1
We need to remove at least 1 element
which is 22 from set1 to make two
sets disjoint.
Input : set1[] = {20, 21, 22}
set2[] = {22, 23, 24, 25, 20}
Output : 2
Input : set1[] = {6, 7}
set2[] = {12, 13, 14, 15}
Output : 0
If we take a closer look at this problem, we can observe that the problem reduces to finding intersection of two sets.
A simple solution is iterate through every element of first set and for every element, check if it is present in second set. If present, increment count of elements to be removed.
C++
#include<bits/stdc++.h>
using namespace std;
int makeDisjoint(int set1[], int set2[], int n, int m)
{
int result = 0;
for (int i=0; i<n; i++)
{
int j;
for (j=0; j<m; j++)
if (set1[i] == set2[j])
break;
if (j != m)
result++;
}
return result;
}
int main()
{
int set1[] = {20, 21, 22};
int set2[] = {22, 23, 24, 25, 20};
int n = sizeof(set1)/sizeof(set1[0]);
int m = sizeof(set2)/sizeof(set2[1]);
cout << makeDisjoint(set1, set2, n, m);
return 0;
}
|
Java
import java.io.*;
public class GFG{
static int makeDisjoint(int []set1,
int []set2,
int n,
int m)
{
int result = 0;
for (int i = 0; i < n; i++)
{
int j;
for (j = 0; j < m; j++)
if (set1[i] == set2[j])
break;
if (j != m)
result++;
}
return result;
}
static public void main (String[] args)
{
int []set1 = {20, 21, 22};
int []set2 = {22, 23, 24, 25, 20};
int n = set1.length;
int m = set2.length;
System.out.println(makeDisjoint(set1, set2,
n, m));
}
}
|
Python 3
def makeDisjoint(set1, set2, n, m):
result = 0;
for i in range (0, n - 1):
for j in range(0, m - 1):
if (set1[i] == set2[j]):
break
if (j != m):
result += 1
return result
set1 = [20, 21, 22]
set2 = [22, 23, 24, 25, 20]
n = len(set1)
m = len(set2)
print(makeDisjoint(set1, set2, n, m))
|
C#
using System;
public class GFG{
static int makeDisjoint(int []set1,
int []set2,
int n,
int m)
{
int result = 0;
for (int i = 0; i < n; i++)
{
int j;
for (j = 0; j < m; j++)
if (set1[i] == set2[j])
break;
if (j != m)
result++;
}
return result;
}
static public void Main ()
{
int []set1 = {20, 21, 22};
int []set2 = {22, 23, 24, 25, 20};
int n = set1.Length;
int m = set2.Length;
Console.WriteLine(makeDisjoint(set1, set2,
n, m));
}
}
|
PHP
<?php
function makeDisjoint( $set1, $set2, $n, $m)
{
$result = 0;
for ( $i = 0; $i < $n; $i++)
{
$j;
for ($j = 0; $j < $m; $j++)
if ($set1[$i] == $set2[$j])
break;
if ($j != $m)
$result++;
}
return $result;
}
$set1 = array(20, 21, 22);
$set2 = array(22, 23, 24, 25, 20);
$n = count($set1);
$m = count($set2);
echo makeDisjoint($set1, $set2, $n, $m);
?>
|
Javascript
<script>
function makeDisjoint(set1,set2,n,m)
{
let result = 0;
for (let i = 0; i < n; i++)
{
let j;
for (j = 0; j < m; j++)
if (set1[i] == set2[j])
break;
if (j != m)
result++;
}
return result;
}
let set1=[20, 21, 22];
let set2=[22, 23, 24, 25, 20];
let n = set1.length;
let m = set2.length;
document.write(makeDisjoint(set1, set2,
n, m));
</script>
|
Output:
2
Time complexity : O(m * n)
Auxiliary Space : O(1)
An efficient solution is to use hashing. We create an empty hash and insert all items of set 1 in it. Now iterate through set 2 and for every element, check if it is present is hash. If present, increment count of elements to be removed.
C++
#include<bits/stdc++.h>
using namespace std;
int makeDisjoint(int set1[], int set2[], int n, int m)
{
unordered_set <int> s;
for (int i = 0; i < n; i++)
s.insert(set1[i]);
int result = 0;
for (int i = 0; i < m; i++)
if (s.find(set2[i]) != s.end())
result++;
return result;
}
int main()
{
int set1[] = {20, 21, 22};
int set2[] = {22, 23, 24, 25, 20};
int n = sizeof(set1)/sizeof(set1[0]);
int m = sizeof(set2)/sizeof(set2[1]);
cout << makeDisjoint(set1, set2, n, m);
return 0;
}
|
Java
import java.util.*;
class GFG {
static int makeDisjoint(int set1[], int set2[], int n, int m) {
LinkedHashSet<Integer> s = new LinkedHashSet<Integer>();
for (int i = 0; i < n; i++) {
s.add(set1[i]);
}
int result = 0;
for (int i = 0; i < m; i++) {
if (s.contains(set2[i])) {
result++;
}
}
return result;
}
public static void main(String[] args) {
int set1[] = {20, 21, 22};
int set2[] = {22, 23, 24, 25, 20};
int n = set1.length;
int m = set2.length;
System.out.println(makeDisjoint(set1, set2, n, m));
}
}
|
Python 3
def makeDisjoint(set1, set2, n, m):
s = []
for i in range(n):
s.append(set1[i])
result = 0
for i in range(m):
if set2[i] in s:
result += 1
return result
if __name__ =="__main__":
set1 = [20, 21, 22]
set2 = [22, 23, 24, 25, 20]
n = len(set1)
m = len(set2)
print(makeDisjoint(set1, set2, n, m))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int makeDisjoint(int []set1, int []set2,
int n, int m)
{
HashSet<int> s = new HashSet<int>();
for (int i = 0; i < n; i++)
{
s.Add(set1[i]);
}
int result = 0;
for (int i = 0; i < m; i++)
{
if (s.Contains(set2[i]))
{
result++;
}
}
return result;
}
public static void Main(String[] args)
{
int []set1 = {20, 21, 22};
int []set2 = {22, 23, 24, 25, 20};
int n = set1.Length;
int m = set2.Length;
Console.WriteLine(makeDisjoint(set1, set2, n, m));
}
}
|
Javascript
<script>
function makeDisjoint(set1, set2, n, m) {
let s = new Set();
for (let i = 0; i < n; i++) {
s.add(set1[i]);
}
let result = 0;
for (let i = 0; i < m; i++) {
if (s.has(set2[i])) {
result++;
}
}
return result;
}
let set1 = [20, 21, 22];
let set2 = [22, 23, 24, 25, 20];
let n = set1.length;
let m = set2.length;
document.write(makeDisjoint(set1, set2, n, m));
</script>
|
Output:
2
Time complexity : O(m + n)
Auxiliary Space : O(m)
This article is contributed by smarakchopdar. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.
