Related Articles

# Largest possible Subset from an Array such that no element is K times any other element in the Subset

• Difficulty Level : Medium
• Last Updated : 21 May, 2021

Given an array arr[] consisting of N distinct integers and an integer K, the task is to find the maximum size of a subset possible such that no element in the subset is K times any other element of the subset(i.e. no such pair {n, m} should be present in the subset such that either m = n * K or n = m * K).

Examples:

Input: arr[] = {2, 8, 6, 5, 3}, K = 2
Output:
Explanation:
Only possible pair existing in the array with an element being K( = 2) times the other is {6, 3}.
Hence, all possible subsets which does not contain both the elements of the pair {6, 3} together can be considered.
Therefore, the longest possible subset can be of length 4.

Input: arr[] = {1, 4, 3, 2}, K = 3
output:

Approach:
Follow the steps below to solve the problem:

• Find the number of pairs possible such that one element is K times the other from the given array
• Sort the array in increasing order of elements.
• Traverse the array and store the frequenciindices of array elements in Map.
• Initialize an array visited to mark for every index, whether that element is included(0) or not(1) in the subset.
• Traverse the array again and for every index having vis[i] = 0, check if arr[i] * K is present in the Map or not. If found, then increase the count of pairs and set vis[mp[arr[i] * K]] = 1.
• Finally, print N – count of pairs as the answer.

Below is implementation of above approach:

## C++

 `// C++ implementation of``// the above approach``#include ``#define ll long long``using` `namespace` `std;` `// Function to find the maximum``// size of the required subset``int` `findMaxLen(vector& a, ll k)``{` `    ``// Size of the array``    ``int` `n = a.size();` `    ``// Sort the array``    ``sort(a.begin(), a.end());` `    ``// Stores which index is``    ``// included or excluded``    ``vector<``bool``> vis(n, 0);` `    ``// Stores the indices of``    ``// array elements``    ``map<``int``, ``int``> mp;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``mp[a[i]] = i;``    ``}` `    ``// Count of pairs``    ``int` `c = 0;` `    ``// Iterate through all``    ``// the element``    ``for` `(``int` `i = 0; i < n; ++i) {` `        ``// If element is included``        ``if` `(vis[i] == ``false``) {``            ``int` `check = a[i] * k;` `            ``// Check if a[i] * k is present``            ``// in the array or not``            ``if` `(mp.find(check) != mp.end()) {` `                ``// Increase count of pair``                ``c++;` `                ``// Exclude the pair``                ``vis[mp[check]] = ``true``;``            ``}``        ``}``    ``}` `    ``return` `n - c;``}` `// Driver code``int` `main()``{` `    ``int` `K = 3;``    ``vector arr = { 1, 4, 3, 2 };` `    ``cout << findMaxLen(arr, K);``}`

## Java

 `// Java implementation of``// the above approach``import` `java.util.*;` `class` `GFG{` `// Function to find the maximum``// size of the required subset``static` `int` `findMaxLen(``int``[] a, ``int` `k)``{` `    ``// Size of the array``    ``int` `n = a.length;` `    ``// Sort the array``    ``Arrays.sort(a);` `    ``// Stores which index is``    ``// included or excluded``    ``boolean` `[]vis = ``new` `boolean``[n];` `    ``// Stores the indices of``    ``// array elements``    ``HashMap mp = ``new` `HashMap();``                                      ` `    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``mp.put(a[i], i);``    ``}` `    ``// Count of pairs``    ``int` `c = ``0``;` `    ``// Iterate through all``    ``// the element``    ``for``(``int` `i = ``0``; i < n; ++i)``    ``{` `        ``// If element is included``        ``if` `(vis[i] == ``false``)``        ``{``            ``int` `check = a[i] * k;` `            ``// Check if a[i] * k is present``            ``// in the array or not``            ``if` `(mp.containsKey(check))``            ``{` `                ``// Increase count of pair``                ``c++;` `                ``// Exclude the pair``                ``vis[mp.get(check)] = ``true``;``            ``}``        ``}``    ``}``    ``return` `n - c;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `K = ``3``;``    ``int` `[]arr = { ``1``, ``4``, ``3``, ``2` `};` `    ``System.out.print(findMaxLen(arr, K));``}``}` `// This code is contributed by amal kumar choubey`

## Python3

 `# Python3 implementation of``# the above approach` `# Function to find the maximum``# size of the required subset``def` `findMaxLen(a, k):` `    ``# Size of the array``    ``n ``=` `len``(a)` `    ``# Sort the array``    ``a.sort()` `    ``# Stores which index is``    ``# included or excluded``    ``vis ``=` `[``0``] ``*` `n` `    ``# Stores the indices of``    ``# array elements``    ``mp ``=` `{}` `    ``for` `i ``in` `range``(n):``        ``mp[a[i]] ``=` `i` `    ``# Count of pairs``    ``c ``=` `0` `    ``# Iterate through all``    ``# the element``    ``for` `i ``in` `range``(n):` `        ``# If element is included``        ``if``(vis[i] ``=``=` `False``):``            ``check ``=` `a[i] ``*` `k` `            ``# Check if a[i] * k is present``            ``# in the array or not``            ``if``(check ``in` `mp.keys()):` `                ``# Increase count of pair``                ``c ``+``=` `1` `                ``# Exclude the pair``                ``vis[mp[check]] ``=` `True` `    ``return` `n ``-` `c` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``K ``=` `3``    ``arr ``=` `[ ``1``, ``4``, ``3``, ``2` `]` `    ``print``(findMaxLen(arr, K))` `# This code is contributed by Shivam Singh`

## C#

 `// C# implementation of``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to find the maximum``// size of the required subset``static` `int` `findMaxLen(``int``[] a, ``int` `k)``{` `    ``// Size of the array``    ``int` `n = a.Length;` `    ``// Sort the array``    ``Array.Sort(a);` `    ``// Stores which index is``    ``// included or excluded``    ``bool` `[]vis = ``new` `bool``[n];` `    ``// Stores the indices of``    ``// array elements``    ``Dictionary<``int``,``               ``int``> mp = ``new` `Dictionary<``int``,``                                        ``int``>();``                                    ` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``mp.Add(a[i], i);``    ``}` `    ``// Count of pairs``    ``int` `c = 0;` `    ``// Iterate through all``    ``// the element``    ``for``(``int` `i = 0; i < n; ++i)``    ``{` `        ``// If element is included``        ``if` `(vis[i] == ``false``)``        ``{``            ``int` `check = a[i] * k;` `            ``// Check if a[i] * k is present``            ``// in the array or not``            ``if` `(mp.ContainsKey(check))``            ``{` `                ``// Increase count of pair``                ``c++;` `                ``// Exclude the pair``                ``vis[mp[check]] = ``true``;``            ``}``        ``}``    ``}``    ``return` `n - c;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `K = 3;``    ``int` `[]arr = { 1, 4, 3, 2 };` `    ``Console.Write(findMaxLen(arr, K));``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``
Output:
`3`

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

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.

My Personal Notes arrow_drop_up