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 the 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:
- Adding a number K to all indices except one (say index X) is the same as removing K from the value at index X.
- This reduces the bound to search for the final array element to lower than equal to the minimum value present in the given array.
- Let the minimum value be A, then the final value after optimal operations can either be A, A – 1, or A – 2.
- The reason A – 3 and so on are not considered in the calculation is because A + 1 takes 2 steps to reach there (-1, -2 ), A + 2 requires one step in reaching A – 3 (- 5) but can easily reach A requires in a single step(A+1 requires 1 step(-1) to reach A and A + 2 requires 1 step(-2) to reach A).
- Also, A + 3 requires 2 steps (-5, -1) to reach A – 3 and 2 steps to reach A again (-1, -2).
- Therefore, A – 3 or any lower bases are not needed to be considered.
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:
C++
#include <bits/stdc++.h>
using namespace std;
int calculate_steps( int arr[], int n,
int minimum)
{
int count = 0;
for ( int i = 0; i < n; i++) {
int val = arr[i];
if (arr[i] > minimum) {
arr[i] = arr[i] - minimum;
count += arr[i] / 5;
arr[i] = arr[i] % 5;
count += arr[i] / 2;
arr[i] = arr[i] % 2;
if (arr[i]) {
count++;
}
}
arr[i] = val;
}
return count;
}
int solve( int arr[], int n)
{
sort(arr, arr + n, greater< int >());
int minimum = arr[n - 1];
int count1 = 0, count2 = 0, count3 = 0;
count1 = calculate_steps(arr, n, minimum);
count2 = calculate_steps(arr, n, minimum - 1);
count3 = calculate_steps(arr, n, minimum - 2);
return min(count1, min(count2, count3));
}
int main()
{
int arr[] = { 3, 6, 6 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << solve(arr, N);
}
|
Java
import java.util.*;
class GFG{
static int calculate_steps(Integer arr[],
int n, int minimum)
{
int count = 0 ;
for ( int i = 0 ; i < n; i++)
{
int val = arr[i];
if (arr[i] > minimum)
{
arr[i] = arr[i] - minimum;
count += arr[i] / 5 ;
arr[i] = arr[i] % 5 ;
count += arr[i] / 2 ;
arr[i] = arr[i] % 2 ;
if (arr[i] > 0 )
{
count++;
}
}
arr[i] = val;
}
return count;
}
static int solve(Integer arr[], int n)
{
Arrays.sort(arr, Collections.reverseOrder());
int minimum = arr[n - 1 ];
int count1 = 0 , count2 = 0 , count3 = 0 ;
count1 = calculate_steps(arr, n,
minimum);
count2 = calculate_steps(arr, n,
minimum - 1 );
count3 = calculate_steps(arr, n,
minimum - 2 );
return Math.min(count1, Math.min(count2,
count3));
}
public static void main(String[] args)
{
Integer arr[] = { 3 , 6 , 6 };
int N = arr.length;
System.out.print(solve(arr, N));
}
}
|
Python3
def calculate_steps(arr, n, minimum):
count = 0
for i in range (n):
val = arr[i]
if (arr[i] > minimum):
arr[i] = arr[i] - minimum
count + = arr[i] / / 5
arr[i] = arr[i] % 5
count + = arr[i] / / 2
arr[i] = arr[i] % 2
if (arr[i]):
count + = 1
arr[i] = val
return count
def solve(arr, n):
arr = sorted (arr)
arr = arr[:: - 1 ]
minimum = arr[n - 1 ]
count1 = 0
count2 = 0
count3 = 0
count1 = calculate_steps(arr, n, minimum)
count2 = calculate_steps(arr, n, minimum - 1 )
count3 = calculate_steps(arr, n, minimum - 2 )
return min (count1, min (count2, count3))
if __name__ = = '__main__' :
arr = [ 3 , 6 , 6 ]
N = len (arr)
print (solve(arr, N))
|
C#
using System;
public class GFG{
static int calculate_steps( int []arr, int n,
int minimum)
{
int count = 0;
for ( int i = 0; i < n; i++) {
int val = arr[i];
if (arr[i] > minimum) {
arr[i] = arr[i] - minimum;
count += arr[i] / 5;
arr[i] = arr[i] % 5;
count += arr[i] / 2;
arr[i] = arr[i] % 2;
if (arr[i]>0) {
count++;
}
}
arr[i] = val;
}
return count;
}
static int solve( int []arr, int n)
{
Array.Sort(arr);
Array.Reverse(arr);
int minimum = arr[n - 1];
int count1 = 0, count2 = 0, count3 = 0;
count1 = calculate_steps(arr, n, minimum);
count2 = calculate_steps(arr, n, minimum - 1);
count3 = calculate_steps(arr, n, minimum - 2);
return Math.Min(count1, Math.Min(count2, count3));
}
public static void Main(String[] args)
{
int []arr = { 3, 6, 6 };
int N = arr.Length;
Console.Write(solve(arr, N));
}
}
|
Javascript
<script>
function calculate_steps(arr, n, minimum) {
var count = 0;
for ( var i = 0; i < n; i++) {
var val = arr[i];
if (arr[i] > minimum) {
arr[i] = arr[i] - minimum;
count += parseInt(arr[i] / 5);
arr[i] = arr[i] % 5;
count += parseInt(arr[i] / 2);
arr[i] = arr[i] % 2;
if (arr[i]) {
count++;
}
}
arr[i] = val;
}
return count;
}
function solve(arr, n) {
arr.sort((a, b) => b - a);
var minimum = arr[n - 1];
var count1 = 0,
count2 = 0,
count3 = 0;
count1 = calculate_steps(arr, n, minimum);
count2 = calculate_steps(arr, n, minimum - 1);
count3 = calculate_steps(arr, n, minimum - 2);
return Math.min(count1, Math.min(count2, count3));
}
var arr = [3, 6, 6];
var N = arr.length;
document.write(solve(arr, N));
</script>
|
Time Complexity: O(N), where N is the size of the given array.
Auxiliary Space: O(1)
Last Updated :
13 Sep, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...