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: 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 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++ 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 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 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# 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
 

<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>

3

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