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

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 frequency indices 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*log(N))
Auxiliary Space: O(N)

Previous
Next