Make the array elements equal by performing given operations minimum number of times

Last Updated : 21 Apr, 2021

Given an array arr[] of size N, the task is to make all the array elements equal by performing following operations minimum number of times:

Increase all array elements of any suffix array by 1.
Decrease all the elements of any suffix array by 1.
Replace any array element y another.

Examples:

Input: arr[] = {99, 96, 97, 95}
Output: 3
Explanation:
Operation 1: Replace a₁ by a₂, i.e. 99 ? 96. The array arr[] modifies to {96, 96, 97, 95}.
Operation 2: Increment the suffix { a₄} by 2, i.e., 95 ? 97. The array arr[] modifies to {96, 96, 97, 97}.
Operation 3: Decrement the suffix { a₃ } by 1, i.e., 97 ? 96. The array arr[] modifies to {96, 96, 96, 96}.
Hence, the total number of operations required is 3.

Input: arr[] = {1, -1, 0, 1, 1}
Output: 2

Approach: The idea is to find the difference between the actual sum and the sum of the array having all elements equal and then choose the operations to perform such that it leads to the minimum count of operations. Follow the steps below to solve the problem:

Initialize a variable, say totOps, to store the actual operations needed to make all the array elements equal.
Traverse the array and store the difference between all pair of consecutive elements and store their sum in totOps.
Initialize a variable, say maxOps, to store the maximum count of operations required.
Now, find the maximum change that occurs while changing an element and store it in the maxOps variable. There are three cases:
- For the 1st element i.e. arr[1], the optimal way to change arr[1] is to make it arr[2].
- For the last element i.e. arr[N], the optimal way to change arr[N] is to make it into arr[N-1].
- For the rest of the element, changing arr[i] affects both arr[i-1] and arr[i+1], therefore, the maximum change is abs(arr[i]- arr[i+1]) + abs(arr[i]- arr[i-1]) - abs(arr[i-1]- arr[i+1).
Therefore, the minimum operations required is equal to the difference between totOps and maxOps.

Below is the implementation of the above approach:

C++

// C++ Program for the above approach  #include <bits/stdc++.h> using namespace std;  // Function to calculate the minimum // operations of given type required // to make the array elements equal void minOperation(int a[], int N) {     // Stores the total count of operations     int totOps = 0;      // Traverse the array     for (int i = 0; i < N - 1; i++) {          // Update difference between         // pairs of adjacent elements         totOps += abs(a[i] - a[i + 1]);     }      // Store the maximum count of operations     int maxOps         = max(abs(a[0] - a[1]),               abs(a[N - 1] - a[N - 2]));      for (int i = 1; i < N - 1; i++) {          // Rest of the elements         maxOps             = max(maxOps, abs(a[i] - a[i - 1])                               + abs(a[i] - a[i + 1])                               - abs(a[i - 1] - a[i + 1]));     }      // Total Operation - Maximum Operation     cout << totOps - maxOps << endl; }  // Driver Code int main() {     // Given array     int arr[] = { 1, -1, 0, 1, 1 };      // Size of the array     int N = sizeof(arr) / sizeof(arr[0]);      minOperation(arr, N);      return 0; }

Java

// Java Program for the above approach import java.io.*; class GFG  {    // Function to calculate the minimum   // operations of given type required   // to make the array elements equal   static void minOperation(int a[], int N)   {      // Stores the total count of operations     int totOps = 0;      // Traverse the array     for (int i = 0; i < N - 1; i++)      {        // Update difference between       // pairs of adjacent elements       totOps += Math.abs(a[i] - a[i + 1]);     }      // Store the maximum count of operations     int maxOps       = Math.max(Math.abs(a[0] - a[1]),                  Math.abs(a[N - 1] - a[N - 2]));      for (int i = 1; i < N - 1; i++)      {        // Rest of the elements       maxOps = Math.max(         maxOps,         Math.abs(a[i] - a[i - 1])         + Math.abs(a[i] - a[i + 1])         - Math.abs(a[i - 1] - a[i + 1]));     }      // Total Operation - Maximum Operation     System.out.println(totOps - maxOps);   }    // Driver Code   public static void main(String[] args)   {      // Given array     int[] arr = { 1, -1, 0, 1, 1 };      // Size of the array     int N = arr.length;      minOperation(arr, N);   } }  // This code is contributed by Dharanendra L V

Python3

# Python3 Program for the above approach  # Function to calculate the minimum # operations of given type required # to make the array elements equal def minOperation(a, N):        # Stores the total count of operations     totOps = 0      # Traverse the array     for i in range(N - 1):          # Update difference between         # pairs of adjacent elements         totOps += abs(a[i] - a[i + 1])      # Store the maximum count of operations     maxOps = max(abs(a[0] - a[1]), abs(a[N - 1] - a[N - 2]))     for i in range(1, N - 1):          # Rest of the elements         maxOps = max(maxOps, abs(a[i] - a[i - 1]) +                       abs(a[i] - a[i + 1])- abs(a[i - 1] - a[i + 1]))      # Total Operation - Maximum Operation     print (totOps - maxOps)  # Driver Code if __name__ == '__main__':        # Given array     arr = [1, -1, 0, 1, 1]      # Size of the array     N = len(arr)     minOperation(arr, N)  # This code is contributed by mohit kumar 29.

// C# Program for the above approach using System; public class GFG {    // Function to calculate the minimum   // operations of given type required   // to make the array elements equal   static void minOperation(int[] a, int N)   {     // Stores the total count of operations     int totOps = 0;      // Traverse the array     for (int i = 0; i < N - 1; i++)      {        // Update difference between       // pairs of adjacent elements       totOps += Math.Abs(a[i] - a[i + 1]);     }      // Store the maximum count of operations     int maxOps       = Math.Max(Math.Abs(a[0] - a[1]),                  Math.Abs(a[N - 1] - a[N - 2]));      for (int i = 1; i < N - 1; i++)      {        // Rest of the elements       maxOps = Math.Max(         maxOps,         Math.Abs(a[i] - a[i - 1])         + Math.Abs(a[i] - a[i + 1])         - Math.Abs(a[i - 1] - a[i + 1]));     }      // Total Operation - Maximum Operation     Console.WriteLine(totOps - maxOps);   }    // Driver Code   static public void Main()   {      // Given array     int[] arr = { 1, -1, 0, 1, 1 };      // Size of the array     int N = arr.Length;      minOperation(arr, N);   } }  // This code is contributed by Dharanendra L V

JavaScript

<script> // javascript Program for the above approach      // Function to calculate the minimum     // operations of given type required     // to make the array elements equal     function minOperation(a , N) {          // Stores the total count of operations         var totOps = 0;          // Traverse the array         for (i = 0; i < N - 1; i++) {              // Update difference between             // pairs of adjacent elements             totOps += Math.abs(a[i] - a[i + 1]);         }          // Store the maximum count of operations         var maxOps = Math.max(Math.abs(a[0] - a[1]), Math.abs(a[N - 1] - a[N - 2]));          for (i = 1; i < N - 1; i++) {              // Rest of the elements             maxOps = Math.max(maxOps,                     Math.abs(a[i] - a[i - 1]) + Math.abs(a[i] - a[i + 1]) - Math.abs(a[i - 1] - a[i + 1]));         }          // Total Operation - Maximum Operation         document.write(totOps - maxOps);     }      // Driver Code               // Given array         var arr = [ 1, -1, 0, 1, 1 ];          // Size of the array         var N = arr.length;          minOperation(arr, N);  // This code contributed by aashish1995  </script>

Output:

Time Complexity: O(N)
Auxiliary Space: O(1)

Minimum number of increment-other operations to make all array elements equal.

atulbelievethat02

Improve

Article Tags :

Practice Tags :

Make the array elements equal by performing given operations minimum number of times

Similar Reads