Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Largest subset with maximum difference as 1

  • Difficulty Level : Easy
  • Last Updated : 21 Jun, 2021

Given an array arr[] of n positive integers. The task is to find the size of the subset formed from the elements of the given array and the absolute difference between any two elements of the set is less than equal to 1.
Examples : 
 

Input : arr[] = {8, 9, 8, 7, 8, 9, 10, 11}
Output : 5
If we make subset with elements {8, 9, 8, 8, 9}. 
Each pair in the subset has an absolute 
difference <= 1 

Input : arr[] = {4, 5, 2, 4, 4, 4}
Output : 5
Subset is {4, 5, 4, 4, 4}

 

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.

Observe, since we want the absolute difference between any two elements to be less than equal to 1, then there can be a maximum of two distinct numbers. So, the subset we choose will be in the form {a, a, a, ….., b, b, b} or {a, a, a, a, …..}. 
Now, to find the size of such subset we will find the frequency of each element say c1, c2, c3, …., cj, …., cmaximum element in arr. Then our answer will be maximal value of ci + ci+1.
Below is the implementation of this approach: 
 

C++




// CPP Program to find the size of
// the subset formed from the elements
// of the given array such that the
// maximum difference is 1
#include <bits/stdc++.h>
using namespace std;
 
// Return the maximum size of subset with
// absolute difference between any element
// is less than 1.
int maxsizeSubset(int arr[], int n)
{
    // Inserting elements and their
    // frequencies in a hash table.
    unordered_map<int, int> mp;
    for (int i = 0; i < n; i++)
        mp[arr[i]]++;
 
    // Traverse through map, for every element
    // x in map, find if x+1 also exists in map.
    // If exists, see if sum of their frequencies
    // is more than current result.
    int res = 0;
    for (auto x : mp)
    if (mp.find(x.first + 1) != mp.end())
    {
        res = max(res, mp[x.first] + mp[x.first+1]);
    }
    else
    {
        res=max(res,mp[x.first]);
    }
    return res;
}
 
// Driven Program
int main()
{
    int arr[] = {1, 2, 2, 3, 1, 2};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << maxsizeSubset(arr, n) << endl;
    return 0;
}

Java




// Java Program to find the size of
// the subset formed from the elements
// of the given array such that the
// maximum difference is 1
import java.util.*;
 
class GFG
{
 
    // Return the maximum size of subset with
    // absolute difference between any element
    // is less than 1.
    static int maxsizeSubset(int arr[], int n)
    {
        // Inserting elements and their
        // frequencies in a hash table.
        Map<Integer, Integer> mp = new HashMap<>();
        for (int i = 0; i < n; i++)
        {
            if (mp.containsKey(arr[i]))
            {
                mp.put(arr[i], mp.get(arr[i]) + 1);
            }
            else
            {
                mp.put(arr[i], 1);
            }
        }
 
        // Traverse through map, for every element
        // x in map, find if x+1 also exists in map.
        // If exists, see if sum of their frequencies
        // is more than current result.
        int res = 0;
        for (Map.Entry<Integer, Integer> x : mp.entrySet())
        {
            if (mp.containsKey(x.getKey() + 1))
            {
                res = Math.max(res, mp.get(x.getKey()) + mp.get(x.getKey() + 1));
            }
            else
            {
                res = Math.max(res, mp.get(x.getKey()));
            }
        }
        return res;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = {1, 2, 2, 3, 1, 2};
        int n = arr.length;
        System.out.println(maxsizeSubset(arr, n));
    }
}
 
/* This code is contributed by PrinciRaj1992 */

C#




// C# Program to find the size of
// the subset formed from the elements
// of the given array such that the
// maximum difference is 1
using System;
using System.Collections.Generic;
 
class GFG
{
 
    // Return the maximum size of subset with
    // absolute difference between any element
    // is less than 1.
    static int maxsizeSubset(int []arr, int n)
    {
        // Inserting elements and their
        // frequencies in a hash table.
        Dictionary<int,
                   int> mp = new Dictionary<int,
                                            int>();
        for (int i = 0 ; i < n; i++)
        {
            if(mp.ContainsKey(arr[i]))
            {
                var val = mp[arr[i]];
                mp.Remove(arr[i]);
                mp.Add(arr[i], val + 1);
            }
            else
            {
                mp.Add(arr[i], 1);
            }
        }
 
        // Traverse through map, for every element
        // x in map, find if x+1 also exists in map.
        // If exists, see if sum of their frequencies
        // is more than current result.
        int res = 0;
        foreach(KeyValuePair<int, int > x in mp)
        {
            if (mp.ContainsKey(x.Key + 1))
            {
                res = Math.Max(res, mp[x.Key] + mp[x.Key + 1]);
            }
            else
            {
                res = Math.Max(res, mp[x.Key]);
            }
        }
        return res;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int []arr = {1, 2, 2, 3, 1, 2};
        int n = arr.Length;
        Console.WriteLine(maxsizeSubset(arr, n));
    }
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
// Javascript Program to find the size of
// the subset formed from the elements
// of the given array such that the
// maximum difference is 1
 
 
// Return the maximum size of subset with
// absolute difference between any element
// is less than 1.
function maxsizeSubset(arr, n) {
    // Inserting elements and their
    // frequencies in a hash table.
    let mp = new Map();
    for (let i = 0; i < n; i++) {
        if (mp.has(arr[i])) {
            mp.set(arr[i], mp.get(arr[i]) + 1)
        } else {
            mp.set(arr[i], 1)
        }
    }
 
    // Traverse through map, for every element
    // x in map, find if x+1 also exists in map.
    // If exists, see if sum of their frequencies
    // is more than current result.
    let res = 0;
    for (let x of mp)
        if (mp.has(x[0] + 1)) {
            res = Math.max(res, mp.get(x[0]) + mp.get(x[0] + 1));
        }
        else {
            res = Math.max(res, mp.get(x[0]));
        }
    return res;
}
 
// Driven Program
let arr = [1, 2, 2, 3, 1, 2];
let n = arr.length;
document.write(maxsizeSubset(arr, n) + "<br>");
 
// This code is contributed by gfgking.
</script>
Output: 
5

 

Time Complexity : O(n) 
Auxiliary Space : O(n)
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :