Skip to content
Related Articles

Related Articles

Make all array elements equal to K by repeatedly incrementing subsequences
  • Last Updated : 26 Feb, 2021

Given an array arr[] consisting of N integers and an integer K, the task is to make all array elements equal to K by repetedly incrementing all elements of subsequences by 1
Note: The value of K is at least the maximum element of the array.

Examples:

Input: arr[] = {2, 3, 3, 4}, K = 5
Output:
Explanation: 
Operation 1: Select the subsequence {2, 3, 4}. After incrementing each element, the subsequence modifies to {3, 4, 5}. The array modifies to {3, 3, 4, 5}. 
Operation 2: Select the subsequence {3, 4}. After incrementing each element, the subsequence modifies to {4, 5}. The array modifies to {3, 4, 5, 5}. 
Operation 3: Select the subsequence {3, 4}. After incrementing each element, the subsequence modifies to {4, 5}. The array modifies to {4, 5, 5, 5}. 
Operation 4: Select the subsequence {4}. After incrementing each element, the subsequence modifies to {5}.The array modifies to {5, 5, 5, 5}.
 

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

Approach: The idea is to use Hashing to keep track of the elements in the subsequences. When an element in a subsequence is increased by 1, its frequency reduces by 1 and the frequency of its modified value increases by 1
Follow the steps below to solve the problem:



  • Initialize a variable, say ans, that stores the minimum number of operations required.
  • Initialize a Hashmap, say mp, and store the frequency of array elements.
  • While the frequency of K is less than N, i.e., mp[K] < N, perform the following operations:
    • Iterate through a range [1, K – 1] using the variable i
      • If mp[i] is greater than 0, decrease the frequency of the current value and increase the frequency of the next group (i + 1) elements by 1.
      • If (i + 1) is not part of any previous value, skip it and continue traversing the loop.
    • Increment the value of ans by 1.
  • After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum number
// of operations required to make all
// elements equal to k
void minOperations(int arr[], int n, int k)
{
    // Initialize a hashmap
    map<int, int> mp;
 
    // Store frequency of array elements
    for (int i = 0; i < n; i++) {
        mp[arr[i]]++;
    }
 
    // Store the minimum number of
    // operations required
    int ans = 0;
 
    // Iterate until all array elements
    // becomes equal to K
    while (mp[k] < n) {
 
        // Iterate through range [1, k - 1]
        // since only one element can be
        // increased from each group
        for (int i = 1; i <= k - 1; i++) {
 
            // Check if the current number
            // has frequency > 0, i.e.,
            // it is a part of a group
            if (mp[i]) {
 
                // If true, decrease the
                // frequency of current
                // group of element by 1
                mp[i]--;
 
                // Increase the frequency
                // of the next group of
                // elements by 1
                mp[i + 1]++;
 
                // If the next element is
                // not the part of any
                // group, then skip it
                if (mp[i + 1] == 1) {
                    i++;
                }
            }
        }
 
        // Increment count of operations
        ans++;
    }
 
    // Print the count of operations
    cout << ans;
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 3, 3, 4 };
    int K = 5;
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    minOperations(arr, N, K);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG
{
 
  // Function to find the minimum number
  // of operations required to make all
  // elements equal to k
  static void minOperations(int arr[], int n, int k)
  {
 
    // Initialize a hashmap
    Map<Integer, Integer> mp = new HashMap<>();
 
    // Store frequency of array elements
    for (int i = 0; i < n; i++)
    {
      if (mp.containsKey(arr[i]))
      {
        mp.put(arr[i], mp.get(arr[i]) + 1);
      }
      else
      {
        mp.put(arr[i], 1);
      }
    }
 
    // Store the minimum number of
    // operations required
    int ans = 0;
 
    // Iterate until all array elements
    // becomes equal to K
    while (mp.containsKey(k) == false
           || mp.get(k) < n) {
 
      // Iterate through range [1, k - 1]
      // since only one element can be
      // increased from each group
      for (int i = 1; i <= k - 1; i++) {
 
        // Check if the current number
        // has frequency > 0, i.e.,
        // it is a part of a group
        if (mp.containsKey(i) && mp.get(i) > 0) {
 
          // If true, decrease the
          // frequency of current
          // group of element by 1
          mp.put(i, mp.get(i) - 1);
 
          // Increase the frequency
          // of the next group of
          // elements by 1
          if (mp.containsKey(i + 1))
            mp.put(i + 1, mp.get(i + 1) + 1);
          else
            mp.put(i + 1, 1);
 
          // If the next element is
          // not the part of any
          // group, then skip it
          if (mp.containsKey(i + 1)
              && mp.get(i + 1) == 1) {
            i++;
          }
        }
      }
 
      // Increment count of operations
      ans++;
    }
 
    // Print the count of operations
    System.out.print(ans);
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    int arr[] = { 2, 3, 3, 4 };
    int K = 5;
    int N = arr.length;
 
    // Function Call
    minOperations(arr, N, K);
  }
}
 
// This code is contributed by Dharanendra L V.

C#




// C# program for the above approach
 
using System;
using System.Collections.Generic;
 
public class GFG
{
 
  // Function to find the minimum number
  // of operations required to make all
  // elements equal to k
  static void minOperations(int []arr, int n, int k)
  {
 
    // Initialize a hashmap
    Dictionary<int, int> mp = new Dictionary<int, int>();
 
    // Store frequency of array elements
    for (int i = 0; i < n; i++)
    {
      if (mp.ContainsKey(arr[i]))
      {
        mp[arr[i]] =  mp[arr[i]] + 1;
      }
      else
      {
        mp.Add(arr[i], 1);
      }
    }
 
    // Store the minimum number of
    // operations required
    int ans = 0;
 
    // Iterate until all array elements
    // becomes equal to K
    while (mp.ContainsKey(k) == false
           || mp[k] < n) {
 
      // Iterate through range [1, k - 1]
      // since only one element can be
      // increased from each group
      for (int i = 1; i <= k - 1; i++) {
 
        // Check if the current number
        // has frequency > 0, i.e.,
        // it is a part of a group
        if (mp.ContainsKey(i) && mp[i] > 0) {
 
          // If true, decrease the
          // frequency of current
          // group of element by 1
          mp[i] = mp[i] - 1;
 
          // Increase the frequency
          // of the next group of
          // elements by 1
          if (mp.ContainsKey(i + 1))
            mp[i + 1] = mp[i + 1] + 1;
          else
            mp.Add(i + 1, 1);
 
          // If the next element is
          // not the part of any
          // group, then skip it
          if (mp.ContainsKey(i + 1)
              && mp[i + 1] == 1) {
            i++;
          }
        }
      }
 
      // Increment count of operations
      ans++;
    }
 
    // Print the count of operations
    Console.Write(ans);
  }
 
  // Driver Code
  public static void Main(String[] args)
  {
    int []arr = { 2, 3, 3, 4 };
    int K = 5;
    int N = arr.Length;
 
    // Function Call
    minOperations(arr, N, K);
  }
}
 
 
// This code is contributed by 29AjayKumar
Output: 
4

 

Time Complexity: O(N*K)
Auxiliary space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :