Largest subset with M as smallest missing number
Last Updated :
21 Jul, 2022
Given an array arr[] of N positive integers and a positive integer M, the task is to find the length of longest subset whose smallest missing integer is M. If no such subset exists, print “-1”.
Examples:
Input: arr[] = {1, 2, 4}, M = 3
Output: 3
Explanation:
Possible subsets of the given array are {1}, {2}, {3}, {1, 2}, {2, 4}, {1, 4} and {1, 2, 4}.
Among these, the subsets containing elements in the range [1, M – 1] but not M is {1, 2} and {1, 2, 4}.
These subsets contain 3 as the smallest missing positive integer.
Therefore, subset {1, 2, 4} is the longest required subset with length 3.
Input: arr[] = {2, 2, 3}, M = 4
Output: -1
Explanation:
The smallest missing positive integer in the array is 1.
Therefore, all possible subsets of the array will have 1 as the smallest missing positive integer.
Therefore, no subset exists with 4 as the minimum missing integer.
Naive Approach: The simplest approach is to generate all possible subsets of the given array and store the maximum length among those subsets whose minimum missing integer is M. Finally, print the maximum length as the answer.
Time Complexity: O(N*2N)
Auxiliary Space: O(N)
Efficient Approach:
To optimize the above approach, consider the following observations. If no element smaller than M is missing in the array, the size of the largest subset will be the 1, consisting of all the array elements excluding M. Otherwise, no subset with the smallest missing number M is possible.
Follow the steps below:
- Insert all elements of the array except M, into the set.
- Find the frequency of elements(say, cnt) in the array arr[], which are not equal to M.
- Find the minimum missing number in the set and if it is equal to M, then print the value of cnt as the maximum size of the subset.
- Otherwise, print “-1”, as no subset is possible with minimum missing number as M.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
ll findLengthOfMaxSubset( int arr[],
int n, int m)
{
set< int > s;
int answer = 0;
for ( int i = 0; i < n; i++) {
int tmp = arr[i];
if (tmp != m) {
s.insert(tmp);
answer++;
}
}
int min = 1;
while (s.count(min)) {
min++;
}
if (min != m) {
answer = -1;
}
return answer;
}
int main()
{
int arr[] = { 1, 2, 4 };
int N = sizeof (arr) / sizeof (arr[0]);
int M = 3;
cout << findLengthOfMaxSubset(
arr, N, M);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int findLengthOfMaxSubset( int arr[],
int n, int m)
{
Set<Integer> s = new HashSet<>();
int answer = 0 ;
for ( int i = 0 ; i < n; i++)
{
int tmp = arr[i];
if (tmp != m)
{
s.add(tmp);
answer++;
}
}
int min = 1 ;
while (s.contains(min))
{
min++;
}
if (min != m)
{
answer = - 1 ;
}
return answer;
}
public static void main (String[] args)
{
int arr[] = { 1 , 2 , 4 };
int N = arr.length;
int M = 3 ;
System.out.print(findLengthOfMaxSubset(
arr, N, M));
}
}
|
Python3
def findLengthOfMaxSubset(arr, n, m):
s = [];
answer = 0 ;
for i in range (n):
tmp = arr[i];
if (tmp ! = m):
s.append(tmp);
answer + = 1 ;
min = 1 ;
while (s.count( min )):
min + = 1 ;
if ( min ! = m):
answer = - 1 ;
return answer;
if __name__ = = "__main__" :
arr = [ 1 , 2 , 4 ];
N = len (arr);
M = 3 ;
print (findLengthOfMaxSubset(arr, N, M));
|
C#
using System;
using System.Collections.Generic;
class GFG{
static int findLengthOfMaxSubset( int []arr,
int n, int m)
{
HashSet< int > s = new HashSet< int >();
int answer = 0;
for ( int i = 0; i < n; i++)
{
int tmp = arr[i];
if (tmp != m)
{
s.Add(tmp);
answer++;
}
}
int min = 1;
while (s.Contains(min))
{
min++;
}
if (min != m)
{
answer = -1;
}
return answer;
}
public static void Main ( string [] args)
{
int []arr = { 1, 2, 4 };
int N = arr.Length;
int M = 3;
Console.Write(findLengthOfMaxSubset(arr, N, M));
}
}
|
Javascript
<script>
function findLengthOfMaxSubset(arr, n, m)
{
let s = new Set();
let answer = 0;
for (let i = 0; i < n; i++)
{
let tmp = arr[i];
if (tmp != m)
{
s.add(tmp);
answer++;
}
}
let min = 1;
while (s.has(min))
{
min++;
}
if (min != m)
{
answer = -1;
}
return answer;
}
let arr = [ 1, 2, 4 ];
let N = arr.length;
let M = 3;
document.write(findLengthOfMaxSubset(arr, N, M));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N), since N extra space has been taken.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...