GeeksforGeeks App
Open App
Browser
Continue

# Minimize operations to make both arrays equal by decrementing a value from either or both

Given two arrays A[] and B[] having N integers, the task is to find the minimum operations required to make all the elements of both the array equal where at each operation, the following can be done:

• Decrement the value of A[i] by 1 where i lies in the range [0, N).
• Decrement the value of B[i] by 1 where i lies in the range [0, N).
• Decrement the value of A[i] and B[i] by 1 where i lies in the range [0, N).

Note: Elements in array A[] and B[] need not be equal to one another.

Example:

Input: arr1[] = {1, 2, 3}, arr2[] = {5, 4, 3}
Output: 5
Explanation: Operations can be performed in the following way:

1. Decrement element at index 2 of A[] by 1. Hence, A[] = {1, 2, 2}.
2. Decrement element at index 2 of A[] by 1. Hence, A[] = {1, 2, 1}.
3. Decrement element at index 0 of B[] by 1. Hence, B[] = {4, 4, 3}.
4. Decrement element at index 0 of B[] by 1. Hence, B[] = {3, 4, 3}.
5. Decrement element at index 1 of both A[] and B[] by 1. Hence A[] = {1, 1, 1} and B[] = {3, 3, 3}

Therefore, all the elements of both the arrays A[] and B[] can be made equal in 5 operation which is the minimum possible.

Input: A[] = {7, 2, 8, 5, 3}, B[] = {3, 4, 5, 9, 1}, N = 5
Output: 23

Approach: The given problem can be solved using a Greedy Approach. Since all the possible operations only decrement the array values, all elements must be made equal to the smallest element in the given array. Suppose min_A and min_B are the smallest integers in the array A[] and B[] respectively. Hence the required answer will be the sum of max(A[i] – min_A, B[i] – min_B) for all possible values of i in the range [0, N).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum operations``// required to make elements of each array``// equal of the given two arrays``int` `minOperations(``int` `a[], ``int` `b[], ``int` `N)``{``    ``// Stores the minimum element in array a[]``    ``int` `min_a = *min_element(a, a + N);` `    ``// Stores the minimum element in array b[]``    ``int` `min_b = *min_element(b, b + N);` `    ``// Variable to store the required ans``    ``int` `ans = 0;` `    ``// Iterate over the elements``    ``for` `(``int` `i = 0; i < N; i++) {``        ``// Store the difference between current``        ``// element and minimum of respective array``        ``int` `x = a[i] - min_a;``        ``int` `y = b[i] - min_b;` `        ``// Add maximum of x and y to ans``        ``ans += max(x, y);``    ``}` `    ``// Return Answer``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``int` `a[] = { 7, 2, 8, 5, 3 };``    ``int` `b[] = { 3, 4, 5, 9, 1 };` `    ``int` `N = ``sizeof``(a) / ``sizeof``(b[0]);` `    ``cout << minOperations(a, b, N);` `    ``return` `0;``}`

## C

 `#include ``#include ``#include ``#include ` `int` `max(``int` `a, ``int` `b)``{``  ``return` `(a > b) ? a : b;``}` `int` `minOperations(``int` `a[], ``int` `b[], ``int` `N)``{` `  ``int` `min_a = INT_MAX;``  ``int` `min_b = INT_MAX;` `  ``for` `(``int` `i = 0; i < N; i++)``  ``{``    ``// Stores the minimum element in array a[]``    ``if` `(a[i] < min_a)``      ``min_a = a[i];``    ``// Stores the minimum element in array b[]``    ``if` `(b[i] < min_b)``      ``min_b = b[i];``  ``}``  ``// Variable to store the required ans``  ``int` `ans = 0;` `  ``for` `(``int` `i = 0; i < N; i++)``  ``{``    ``// Store the difference between current``    ``// element and minimum of respective array``    ``int` `x = a[i] - min_a;``    ``int` `y = b[i] - min_b;``    ``// Add maximum of x and y to ans``    ``ans += max(x, y);``  ``}``  ``// Return ans``  ``return` `ans;``}` `int` `main()``{``  ``int` `a[] = {7, 2, 8, 5, 3};``  ``int` `b[] = {3, 4, 5, 9, 1};` `  ``int` `N = ``sizeof``(a) / ``sizeof``(b[0]);` `  ``printf``(``"%d"``, minOperations(a, b, N));` `  ``return` `0;``}` `// This code is contributed by abhinavprkash.`

## Java

 `// Java program for the above approach``import` `java.util.*;` `public` `class` `GFG``{``// Function to find the minimum operations``// required to make elements of each array``// equal of the given two arrays``static` `int` `minOperations(``int` `[]a, ``int` `[]b, ``int` `N)``{``    ``// Stores the minimum element in array a[]``    ``int` `min_a = Arrays.stream(a).min().getAsInt();` `    ``// Stores the minimum element in array b[]``    ``int` `min_b = Arrays.stream(b).min().getAsInt();` `    ``// Variable to store the required ans``    ``int` `ans = ``0``;` `    ``// Iterate over the elements``    ``for` `(``int` `i = ``0``; i < N; i++) {``        ``// Store the difference between current``        ``// element and minimum of respective array``        ``int` `x = a[i] - min_a;``        ``int` `y = b[i] - min_b;` `        ``// Add maximum of x and y to ans``        ``ans += Math.max(x, y);``    ``}` `    ``// Return Answer``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``int` `[]a = { ``7``, ``2``, ``8``, ``5``, ``3` `};``    ``int` `[]b = { ``3``, ``4``, ``5``, ``9``, ``1` `};``    ``int` `N = a.length;``    ` `    ``System.out.println(minOperations(a, b, N));``}``}``// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# Python program for the above approach` `# Function to find the minimum operations``# required to make elements of each array``# equal of the given two arrays``def` `minOperations(a, b, N):` `    ``# Stores the minimum element in array a[]``    ``min_a ``=` `min``(a)` `    ``# Stores the minimum element in array b[]``    ``min_b ``=` `min``(b)` `    ``# Variable to store the required ans``    ``ans ``=` `0` `    ``# Iterate over the elements``    ``for` `i ``in` `range``(N):``      ` `       ``# Store the difference between current``       ``# element and minimum of respective array``        ``x ``=` `a[i] ``-` `min_a``        ``y ``=` `b[i] ``-` `min_b` `       ``# Add maximum of x and y to ans``        ``ans ``+``=` `max``(x, y)` `    ``# Return Answer``    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``a ``=` `[``7``, ``2``, ``8``, ``5``, ``3``]``    ``b ``=` `[``3``, ``4``, ``5``, ``9``, ``1``]``    ``N ``=` `len``(a)``    ``print``(minOperations(a, b, N))` `# This code is contributed by Potta Lokesh`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Linq;` `public` `class` `GFG``{``// Function to find the minimum operations``// required to make elements of each array``// equal of the given two arrays``static` `int` `minOperations(``int` `[]a, ``int` `[]b, ``int` `N)``{``    ``// Stores the minimum element in array a[]``    ``int` `min_a = a.Min();` `    ``// Stores the minimum element in array b[]``    ``int` `min_b = b.Min();` `    ``// Variable to store the required ans``    ``int` `ans = 0;` `    ``// Iterate over the elements``    ``for` `(``int` `i = 0; i < N; i++) {``        ``// Store the difference between current``        ``// element and minimum of respective array``        ``int` `x = a[i] - min_a;``        ``int` `y = b[i] - min_b;` `        ``// Add maximum of x and y to ans``        ``ans += Math.Max(x, y);``    ``}` `    ``// Return Answer``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `[]a = { 7, 2, 8, 5, 3 };``    ``int` `[]b = { 3, 4, 5, 9, 1 };``    ``int` `N = a.Length;``    ` `    ``Console.Write(minOperations(a, b, N));``}``}``// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`23`

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

My Personal Notes arrow_drop_up