Given an array arr[] of size N and an integer K, the task is to check whether it’s possible to split the array into strictly increasing subsets of size at least K. If it is possible then print “Yes“. Otherwise, print “No“.
Examples:
Input: arr[] = {5, 6, 4, 9, 12}, K = 2
Output: Yes
Explanation:
One possible way to split the array into subsets of at least size 2 is, {arr[2](=4), arr[0](=5)} and {arr[1](=6), arr[3](=9), arr[4](=12)}Input: arr[] = {5, 7, 7, 7}, K = 2
Output: No
Approach: The problem can be solved by using Map to store the frequency of every element and dividing the array into X subsets where X is the frequency of the element that occurs maximum number of times in the array. Follow the steps below to solve the problem:
- Initialize a Map say m to store the frequency of elements and also initialize a variable mx as 0 to store the frequency of maximum occurring element in the array arr[].
- Traverse the array arr[] using the variable i, and increment m[arr[i]] by 1 and update the value of mx to max(mx, m[arr[i]]).
- Now if N/mx>= K then prints “Yes” as it the maximum number of elements a subset can have.
- Otherwise, print “No“.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to check if it is possible // to split the array into strictly // increasing subsets of size atleast K string ifPossible( int arr[], int N, int K)
{ // Map to store frequency of elements
map< int , int > m;
// Stores the frequency of the maximum
// occurring element in the array
int mx = 0;
// Traverse the array
for ( int i = 0; i < N; i++) {
m[arr[i]] += 1;
mx = max(mx, m[arr[i]]);
}
// Stores the minimum count of elements
// in a subset
int sz = N / mx;
// If sz is greater than k-1
if (sz >= K) {
return "Yes" ;
}
// Otherwise
else {
return "No" ;
}
} // Driver Code int main()
{ // Given Input
int arr[] = { 5, 6, 4, 9, 12 };
int K = 2;
int N = sizeof (arr) / sizeof (arr[0]);
// Function Call
cout << ifPossible(arr, N, K);
return 0;
} |
// Java approach for the above program import java.util.HashMap;
public class GFG
{ // Function to check if it is possible
// to split the array into strictly
// increasing subsets of size atleast K
static String ifPossible( int arr[], int N, int K)
{
// Map to store frequency of elements
HashMap<Integer, Integer> m
= new HashMap<Integer, Integer>();
// Stores the frequency of the maximum
// occurring element in the array
int mx = 0 ;
// Traverse the array
for ( int i = 0 ; i < N; i++) {
m.put(arr[i], m.getOrDefault(arr[i], 0 ) + 1 );
mx = Math.max(mx, m.get(arr[i]));
}
// Stores the minimum count of elements
// in a subset
int sz = N / mx;
// If sz is greater than k-1
if (sz >= K) {
return "Yes" ;
}
// Otherwise
else {
return "No" ;
}
}
// Driver code
public static void main(String[] args)
{
// Given Input
int arr[] = { 5 , 6 , 4 , 9 , 12 };
int K = 2 ;
int N = arr.length;
// Function Call
System.out.println(ifPossible(arr, N, K));
}
} // This code is contributed by abhinavjain194 |
# Python3 program for the above approach # Function to check if it is possible # to split the array into strictly # increasing subsets of size atleast K def ifPossible(arr, N, K):
# Map to store frequency of elements
m = {}
# Stores the frequency of the maximum
# occurring element in the array
mx = 0
# Traverse the array
for i in range (N):
if arr[i] in m:
m[arr[i]] + = 1
else :
m[arr[i]] = 1
mx = max (mx, m[arr[i]])
# Stores the minimum count of elements
# in a subset
sz = N / / mx
# If sz is greater than k-1
if (sz > = K):
return "Yes"
# Otherwise
else :
return "No"
# Driver Code if __name__ = = '__main__' :
# Given Input
arr = [ 5 , 6 , 4 , 9 , 12 ]
K = 2
N = len (arr)
# Function Call
print (ifPossible(arr, N, K))
# This code is contributed by bgangwar59 |
// C# program for the above approach using System;
using System.Collections.Generic;
class GFG
{ // Function to check if it is possible // to split the array into strictly // increasing subsets of size atleast K static string ifPossible( int []arr, int N, int K)
{ // Map to store frequency of elements
Dictionary< int , int > m = new Dictionary< int , int >();
// Stores the frequency of the maximum
// occurring element in the array
int mx = 0;
// Traverse the array
for ( int i = 0; i < N; i++) {
if (m.ContainsKey(arr[i]))
m[arr[i]] += 1;
else
m.Add(arr[i],1);
mx = Math.Max(mx, m[arr[i]]);
}
// Stores the minimum count of elements
// in a subset
int sz = N / mx;
// If sz is greater than k-1
if (sz >= K) {
return "Yes" ;
}
// Otherwise
else {
return "No" ;
}
} // Driver Code public static void Main()
{ // Given Input
int []arr = { 5, 6, 4, 9, 12 };
int K = 2;
int N = arr.Length;
// Function Call
Console.Write(ifPossible(arr, N, K));
} } // This code is contributed by SURENDRA_GANGWAR. |
<script> // JavaScript program for the above approach // Function to check if it is possible // to split the array into strictly // increasing subsets of size atleast K function ifPossible(arr, N, K)
{ // Map to store frequency of elements
let m = new Map();
// Stores the frequency of the maximum
// occurring element in the array
let mx = 0;
// Traverse the array
for (let i = 0; i < N; i++) {
m[arr[i]] += 1;
if (m.has(arr[i])){
m.set(arr[i], m.get([arr[i]]) + 1)
} else {
m.set(arr[i], 1)
}
mx = Math.max(mx, m.get(arr[i]));
}
// Stores the minimum count of elements
// in a subset
let sz = Math.floor(N / mx);
// If sz is greater than k-1
if (sz >= K) {
return "Yes" ;
}
// Otherwise
else {
return "No" ;
}
} // Driver Code // Given Input
let arr = [ 5, 6, 4, 9, 12 ];
let K = 2;
let N = arr.length;
// Function Call
document.write(ifPossible(arr, N, K));
</script> |
Yes
Time Complexity: O(N*log(N))
Auxiliary Space: O(N)