Minimize steps required to make all array elements same by adding 1, 2 or 5

Given an array arr[] of size N, the task is to count the minimum number of steps required to make all the array elements same by adding 1, 2, or 5 to exactly (N – 1) elements of the array at each step.

Examples:

Input: N = 4, arr[] = {2, 2, 3, 7}
Output: 2
Explanation: 
Step 1: {2, 2, 3, 7} -> {3, 3, 3, 8} 
Step 2: {3, 3, 3, 8} -> {8, 8, 8, 8}

Input: N = 3, arr[] = {10, 7, 12}
Output: 3

Naive Approach: The simplest approach is to try all possible combinations recursively of adding numbers 1, 2, and 5 such that all the elements become the same and calculate the number of steps required for all such combinations. Finally, print the minimum of them as the required answer.



Time Complexity: O(MM), where M is the maximum element present in the array.
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by the following observations:

Therefore, the idea is to find the count of operations required to reduce all the array elements to their minimum element(say minE), minE – 1, and minE – 2 by subtracting 1, 2, and 5. Print the minimum among the above three operations. 

Below is the implementation of the above approach: 

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the minimum
// number of steps
int calculate_steps(int arr[], int n,
                    int minimum)
{
    // count stores number of operations
    // required to make all elements
    // equal to minimum value
    int count = 0;
 
    // Remark, the array should remain
    // unchanged for further calculations
    // with different minumum
    for (int i = 0; i < n; i++) {
 
        // Storing the current value of
        // arr[i] in val
        int val = arr[i];
 
        if (arr[i] > minimum) {
 
            // Finds how much extra amount
            // is to be removed
            arr[i] = arr[i] - minimum;
 
            // Subtract the maximum number
            // of 5 and stores remaining
            count += arr[i] / 5;
 
            arr[i] = arr[i] % 5;
 
            // Subtract the maximum number
            // of 2 and stores remaining
            count += arr[i] / 2;
 
            arr[i] = arr[i] % 2;
 
            if (arr[i]) {
                count++;
            }
        }
 
        // Restores the actual value
        // of arr[i]
        arr[i] = val;
    }
 
    // Return the count
    return count;
}
 
// Function to find the minimum number
// of steps to make array elements same
int solve(int arr[], int n)
{
 
    // Sort the array in descending order
    sort(arr, arr + n, greater<int>());
 
    // Stores the minimum array element
    int minimum = arr[n - 1];
 
    int count1 = 0, count2 = 0, count3 = 0;
 
    // Stores the operations required
    // to make array elements equal to minimum
    count1 = calculate_steps(arr, n, minimum);
 
    // Stores the operations required
    // to make array elements equal to minimum - 1
    count2 = calculate_steps(arr, n, minimum - 1);
 
    // Stores the operations required
    // to make array elements equal to minimum - 2
    count3 = calculate_steps(arr, n, minimum - 2);
 
    // Return minimum of the three counts
    return min(count1, min(count2, count3));
}
 
// Driver Code
int main()
{
    int arr[] = { 3, 6, 6 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << solve(arr, N);
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
class GFG{
 
// Function to calculate the minimum
// number of steps
static int calculate_steps(Integer arr[],
                           int n, int minimum)
{
    // count stores number of operations
    // required to make all elements
    // equal to minimum value
    int count = 0;
 
    // Remark, the array should remain
    // unchanged for further calculations
    // with different minumum
    for (int i = 0; i < n; i++)
    {
        // Storing the current value of
        // arr[i] in val
        int val = arr[i];
 
        if (arr[i] > minimum)
        {
            // Finds how much extra amount
            // is to be removed
            arr[i] = arr[i] - minimum;
 
            // Subtract the maximum number
            // of 5 and stores remaining
            count += arr[i] / 5;
 
            arr[i] = arr[i] % 5;
 
            // Subtract the maximum number
            // of 2 and stores remaining
            count += arr[i] / 2;
 
            arr[i] = arr[i] % 2;
 
            if (arr[i] > 0)
            {
                count++;
            }
        }
 
        // Restores the actual value
        // of arr[i]
        arr[i] = val;
    }
 
    // Return the count
    return count;
}
 
// Function to find the minimum number
// of steps to make array elements same
static int solve(Integer arr[], int n)
{
 
    // Sort the array in descending order
     Arrays.sort(arr, Collections.reverseOrder());
 
    // Stores the minimum array element
    int minimum = arr[n - 1];
 
    int count1 = 0, count2 = 0, count3 = 0;
 
    // Stores the operations required
    // to make array elements equal
    // to minimum
    count1 = calculate_steps(arr, n,
                             minimum);
 
    // Stores the operations required
    // to make array elements equal to
    // minimum - 1
    count2 = calculate_steps(arr, n,
                             minimum - 1);
 
    // Stores the operations required
    // to make array elements equal to
    // minimum - 2
    count3 = calculate_steps(arr, n,
                             minimum - 2);
 
    // Return minimum of the three counts
    return Math.min(count1, Math.min(count2,
                                     count3));
}
 
// Driver Code
public static void main(String[] args)
{
    Integer arr[] = {3, 6, 6};
    int N = arr.length;
    System.out.print(solve(arr, N));
}
}
// This code is contributed by Rajput-Ji
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
 
# Function to calculate the minimum
# number of steps
def calculate_steps(arr, n, minimum):
 
    # count stores number of operations
    # required to make all elements
    # equal to minimum value
    count = 0
 
    # Remark, the array should remain
    # unchanged for further calculations
    # with different minumum
    for i in range(n):
 
        # Storing the current value of
        # arr[i] in val
        val = arr[i]
 
        if (arr[i] > minimum):
 
            # Finds how much extra amount
            # is to be removed
            arr[i] = arr[i] - minimum
 
            # Subtract the maximum number
            # of 5 and stores remaining
            count += arr[i] // 5
 
            arr[i] = arr[i] % 5
 
            # Subtract the maximum number
            # of 2 and stores remaining
            count += arr[i] // 2
 
            arr[i] = arr[i] % 2
 
            if (arr[i]):
                count += 1
 
        # Restores the actual value
        # of arr[i]
        arr[i] = val
 
    # Return the count
    return count
 
# Function to find the minimum number
# of steps to make array elements same
def solve(arr, n):
 
    # Sort the array in descending order
    arr = sorted(arr)
    arr = arr[::-1]
 
    # Stores the minimum array element
    minimum = arr[n - 1]
 
    count1 = 0
    count2 = 0
    count3 = 0
 
    # Stores the operations required
    # to make array elements equal to minimum
    count1 = calculate_steps(arr, n, minimum)
 
    # Stores the operations required
    # to make array elements equal to minimum - 1
    count2 = calculate_steps(arr, n, minimum - 1)
 
    # Stores the operations required
    # to make array elements equal to minimum - 2
    count3 = calculate_steps(arr, n, minimum - 2)
 
    # Return minimum of the three counts
    return min(count1, min(count2, count3))
 
# Driver Code
if __name__ == '__main__':
     
    arr = [ 3, 6, 6 ]
    N = len(arr)
     
    print(solve(arr, N))
 
# This code is contributed by mohit kumar 29
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
 
using System;
 
public class GFG{
 
// Function to calculate the minimum
// number of steps
static int calculate_steps(int []arr, int n,
                    int minimum)
{
    // count stores number of operations
    // required to make all elements
    // equal to minimum value
    int count = 0;
 
    // Remark, the array should remain
    // unchanged for further calculations
    // with different minumum
    for (int i = 0; i < n; i++) {
 
        // Storing the current value of
        // arr[i] in val
        int val = arr[i];
 
        if (arr[i] > minimum) {
 
            // Finds how much extra amount
            // is to be removed
            arr[i] = arr[i] - minimum;
 
            // Subtract the maximum number
            // of 5 and stores remaining
            count += arr[i] / 5;
 
            arr[i] = arr[i] % 5;
 
            // Subtract the maximum number
            // of 2 and stores remaining
            count += arr[i] / 2;
 
            arr[i] = arr[i] % 2;
 
            if (arr[i]>0) {
                count++;
            }
        }
 
        // Restores the actual value
        // of arr[i]
        arr[i] = val;
    }
 
    // Return the count
    return count;
}
 
// Function to find the minimum number
// of steps to make array elements same
static int solve(int []arr, int n)
{
 
    // Sort the array in descending order
    Array.Sort(arr);
    Array.Reverse(arr);
    // Stores the minimum array element
    int minimum = arr[n - 1];
 
    int count1 = 0, count2 = 0, count3 = 0;
 
    // Stores the operations required
    // to make array elements equal to minimum
    count1 = calculate_steps(arr, n, minimum);
 
    // Stores the operations required
    // to make array elements equal to minimum - 1
    count2 = calculate_steps(arr, n, minimum - 1);
 
    // Stores the operations required
    // to make array elements equal to minimum - 2
    count3 = calculate_steps(arr, n, minimum - 2);
 
    // Return minimum of the three counts
    return Math.Min(count1, Math.Min(count2, count3));
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 3, 6, 6 };
 
    int N = arr.Length;
    Console.Write(solve(arr, N));
}
}
  
 
// This code contributed by Rajput-Ji
chevron_right

Output: 
3




 

Time Complexity: O(N), where N is the size of the given array.
Auxiliary Space: O(1)

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.




Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : mohit kumar 29, Rajput-Ji

Article Tags :