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)