Skip to content
Related Articles

Related Articles

Improve Article

Minimum groups to split Array such that their each pair value difference and position difference are same

  • Last Updated : 04 Sep, 2021

Given an array arr[] consisting of N integers, the task is to split the array into the minimum number of disjoint groups, such that differences between any pair of the elements in a group are equal to the difference between their positions in that group.

Examples:

Input: arr[] = {30, 32, 44, 31, 45, 32, 31, 33}
Output: 3
Explanation:
The one possible possible way to split the array is:

  • First group: {30, 31, 32, 33}
  • Second group: {31, 32}
  • Third group: {44, 45}

Therefore, the number of groups is 3, which is the minimum number of groups in which the array can be split satisfying the conditions.

Input: arr[] = {1, 5, 3, 1, 7, 7, 9}
Output: 7



Naive Approach: The simplest approach is, split the array into K subsets for every integer K less than or equal to N, and then check if all the subsets of the array satisfy the given conditions or not. If found to be true, then print the minimum size of the partition possible.

Time Complexity: O(N(N + 2))
Auxiliary Space: O(N)

Efficient Approach: The above approach can be optimized based on the observation that the elements in each group must be sorted and the difference between adjacent elements should be 1. Follow the steps below to solve the problem:

  • Sort the given array in ascending order.
  • Initialize a Map, say mp to store the frequency of array elements.
  • Initialize a variable, say count as 0 to store the count of the minimum number of disjoint groups formed.
  • Traverse the given array arr[], and increment the frequency of each element in the map mp.
  • Traverse the given array arr[], using the variable i, and perform the following steps:
    • If the count of arr[i] in map mp is at least 1, and the count of (arr[i] – 1) in the map mp then:
      • Increment the value of count by 1.
      • Iterate until the count of arr[i] in mp is greater than 0 and in each iteration, decrement mp[arr[i]] by 1 and increment arr[i] by 1.
  • Finally, after completing the above steps, print the value of the count as the answer.

Below is the implementation of the above approach: 

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to split the array into
// minimum number of disjoint groups
// satisfying the conditions
int numberOfSplit(int arr[], int N)
{
    // Sort the array in ascending order
    sort(arr, arr + N);
 
    // Stores frequency of array elements
    unordered_map<int, int> mp;
 
    // Traverse the array, arr[]
    for (int i = 0; i < N; i++)
        mp[arr[i]]++;
 
    // Stores the number of groups
    int count = 0;
 
    // Traverse the array, arr[]
    for (int i = 0; i < N; i++) {
 
        // If mp[arr[i]] is at least 1
        // and  mp[arr[i]-1] is 0
        if (mp[arr[i]] > 0 && mp[arr[i] - 1] == 0) {
 
            // Increment the count by 1
            count++;
 
            // Iterate until mp[arr[i]]
            // is greater than 0
            while (mp[arr[i]] != 0) {
 
                // Decrement mp[arr[i]]
                // by 1
                mp[arr[i]]--;
 
                // Increment arr[i] by 1
                arr[i]++;
            }
        }
    }
 
    // Return the resultant count
    return count;
}
 
// Driver Code
int main()
{
    int arr[] = { 30, 32, 44, 31, 45, 32, 31, 33 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    cout << numberOfSplit(arr, N);
 
    return 0;
}

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to split the array into
// minimum number of disjoint groups
// satisfying the conditions
static int numberOfSplit(int []arr, int N)
{
     
    // Sort the array in ascending order
    Array.Sort(arr);
 
    // Stores frequency of array elements
    Dictionary<int,
               int> mp = new Dictionary<int,
                                        int>();
 
    // Traverse the array, arr[]
    for(int i = 0; i < N; i++)
    {
        if (mp.ContainsKey(arr[i]))
            mp[arr[i]] += 1;
        else
            mp.Add(arr[i], 0);
    }
 
    // Stores the number of groups
    int count = 2;
 
    // Traverse the array, arr[]
    for(int i = 0; i < N; i++)
    {
         
        // If mp[arr[i]] is at least 1
        // and  mp[arr[i]-1] is 0
        if (mp[arr[i]] > 0 && mp[arr[i] - 1] == 0)
        {
             
            // Increment the count by 1
            count++;
 
            // Iterate until mp[arr[i]]
            // is greater than 0
            while (mp[arr[i]] != 0)
            {
                 
                // Decrement mp[arr[i]]
                // by 1
                mp[arr[i]]--;
 
                // Increment arr[i] by 1
                arr[i]++;
            }
        }
    }
   
    // Return the resultant count
    return count;
}
 
// Driver Code
public static void Main()
{
    int []arr = { 30, 32, 44, 31,
                  45, 32, 31, 33 };
    int N = arr.Length;
 
    Console.Write(numberOfSplit(arr, N));
}
}
 
// This code is contributed by SURENDRA_GANGWAR
Output
3

Time Complexity: O(N*log 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
Recommended Articles
Page :