Skip to content
Related Articles

Related Articles

Improve Article

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: 4 
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: 3 
 

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 <bits/stdc++.h>
#define ll long long
using namespace std;
 
// Function to find the maximum
// size of the required subset
int findMaxLen(vector<ll>& 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<ll> 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<Integer,
            Integer> mp = new HashMap<Integer,
                                      Integer>();
                                       
    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



<script>
 
// Javascript implementation of
// the above approach
 
// Function to find the maximum
// size of the required subset
function findMaxLen(a, k)
{
  
    // Size of the array
    let n = a.length;
  
    // Sort the array
    a.sort();
  
    // Stores which index is
    // included or excluded
    let vis = Array.from({length: n}, (_, i) => 0);
  
    // Stores the indices of
    // array elements
    let mp = new Map();
                                        
    for(let i = 0; i < n; i++)
    {
        mp.set(a[i], i);
    }
  
    // Count of pairs
    let c = 0;
  
    // Iterate through all
    // the element
    for(let i = 0; i < n; ++i)
    {
  
        // If element is included
        if (vis[i] == false)
        {
            let check = a[i] * k;
  
            // Check if a[i] * k is present
            // in the array or not
            if (mp.has(check))
            {
  
                // Increase count of pair
                c++;
  
                // Exclude the pair
                vis[mp.get(check)] = true;
            }
        }
    }
    return n - c;
}
 
// Driver code
 
    let K = 3;
    let arr = [ 1, 4, 3, 2 ];
  
    document.write(findMaxLen(arr, K));
 
// This code is contributed by souravghosh0416.
</script>
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
Next

Subset Sum Problem | DP-25
Recommended Articles
Page :
Maximize array product by changing any array element arr[i] to (-1)*arr[i] - 1 any number of times
16, Feb 21
Possible values of Q such that, for any value of R, their product is equal to X times their sum
09, Aug 20
Find maximum subset sum formed by partitioning any subset of array into 2 partitions with equal sum
08, Apr 20
Largest subset where absolute difference of any two element is a power of 2
14, Jan 19
Count of lists which are not a subset of any other given lists
24, Jun 20
Reduce sum of any subset of an array to 1 by multiplying all its elements by any value
25, Feb 21
Count pairs (p, q) such that p occurs in array at least q times and q occurs at least p times
25, Feb 19
Split Array into K non-overlapping subset such that maximum among all subset sum is minimum
20, Jul 21
Maximum possible sum of a window in an array such that elements of same window in other array are unique
04, Aug 17
Partitions possible such that the minimum element divides all the other elements of the partition
20, Jan 20
Maximum possible remainder when an element is divided by other element in the array
19, Nov 19
Minimum number of flips required such that the last cell of matrix can be reached from any other cell
18, Nov 20
Modify a Binary String by flipping characters such that any pair of indices consisting of 1s are neither co-prime nor divisible by each other
02, Mar 21
Minimum deletions required such that any number X will occur exactly X times
20, Jun 19
Lexicographically largest subsequence such that every character occurs at least k times
14, Oct 17
Count of distinct pairs having one element as K times the other
12, Jul 21
Find the length of the Largest subset such that all elements are Pairwise Coprime
29, Apr 20
Largest element in the array that is repeated exactly k times
31, Oct 18
Split array into equal length subsets with maximum sum of Kth largest element of each subset
02, Dec 20
Generate longest possible array with product K such that each array element is divisible by its previous adjacent element
12, Mar 21
Lexicographically largest array possible from first N natural numbers such that every repetation is present at distance equal to its value from its previous occurrence
15, Feb 21
Maximum Subset Sum possible by negating the entire sum after selecting the first Array element
05, Aug 20
Minimum possible value T such that at most D Partitions of the Array having at most sum T is possible
21, Aug 20
Minimum increments to modify array such that value of any array element can be splitted to make all remaining elements equal
25, Dec 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
dreamer07
@dreamer07
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox