 Open in App
Not now

# Check if it’s possible to split the Array into strictly increasing subsets of size at least K

• Difficulty Level : Easy
• Last Updated : 18 Nov, 2021

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(=4), arr(=5)} and {arr(=6), arr(=9), arr(=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++

 `// C++ program for the above approach``#include ``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);` `    ``// Function Call``    ``cout << ifPossible(arr, N, K);``    ``return` `0;``}`

## Java

 `// 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 m``            ``= ``new` `HashMap();` `        ``// 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

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

 `// 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.`

## Javascript

 ``

Output

`Yes`

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

My Personal Notes arrow_drop_up