Open In App

# Minimize operations to make minimum value of one array greater than maximum value of the other

Given two arrays A[] and B[] consisting of N and M integers, the task is to find the minimum number of operations required to make the minimum element of the array A[] at least the maximum element of the array B[] such that in each operation any array element A[] can be incremented by 1 or any array element B[] can be decremented by 1.

Examples:

Input: A[] = {2, 3}, B[] = {3, 5}
Output: 3
Explanation:
Following are the operations performed:

1. Increase the value of A[1] by 1 modifies the array A[] = {3, 3}.
2. Decrease the value of B[2] by 1 modifies the array B[] = {3, 4}.
3. Decrease the value of B[2] by 1 modifies the array B[] = {3, 3}.

After the above operations, the minimum elements of the array A[] is 3 which is greater than or equal to the maximum element of the array B[] is 3. Therefore, the total number of operations is 3.

Input: A[] = {1, 2, 3}, B[] = {4}
Output: 3

Approach: The problem can be solved by using the Greedy Approach. Follow the steps below to solve the given problem:

=> (B[0] + B[1] + … + B[i]) – i*x + (A[0] + A[1] + … + A[i]) + i*x
=> (B[0] – A[0]) + (B[1] – A[1]) + … + (B[i] – A[i]).

• Traverse both the arrays until the value of A[i] is smaller than B[i], and the value of (B[i] – A[i]) to the variable, say ans.
• After completing the above steps, print the value of ans as the minimum number of operations required.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;``#define ll long long` `// Comparator function``bool` `cmp(ll a, ll b) { ``return` `a > b; }` `// Function to find the minimum number``// of operation required to satisfy the``// given conditions``int` `FindMinMoves(vector A, vector B)``{``    ``int` `n, m;``    ``n = A.size();``    ``m = B.size();` `    ``// sort the array A and B in the``    ``// ascending and descending order``    ``sort(A.begin(), A.end());``    ``sort(B.begin(), B.end(), cmp);` `    ``ll ans = 0;` `    ``// Iterate over both the arrays``    ``for` `(``int` `i = 0; i < min(m, n)``                    ``&& A[i] < B[i];``         ``++i) {` `        ``// Add the difference to the``        ``// variable answer``        ``ans += (B[i] - A[i]);``    ``}` `    ``// Return the resultant operations``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``vector A = { 2, 3 };``    ``vector B = { 3, 5 };``    ``cout << FindMinMoves(A, B);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.Arrays;` `class` `GFG{``    ` `// Comparator function``public` `static` `boolean` `cmp(``int` `a, ``int` `b)``{``    ``return` `a > b;``}` `// Function to find the minimum number``// of operation required to satisfy the``// given conditions``public` `static` `int` `FindMinMoves(``int``[] A, ``int``[] B)``{``    ``int` `n, m;``    ``n = A.length;``    ``m = B.length;` `    ``// Sort the array A and B in the``    ``// ascending and descending order``    ``Arrays.sort(A);``    ``Arrays.sort(B);` `    ``int` `ans = ``0``;` `    ``// Iterate over both the arrays``    ``for``(``int` `i = ``0``;``            ``i < Math.min(m, n) && A[i] < B[i]; ++i)``    ``{``        ` `        ``// Add the difference to the``        ``// variable answer``        ``ans += (B[i] - A[i]);``    ``}` `    ``// Return the resultant operations``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``int``[] A = { ``2``, ``3` `};``    ``int``[] B = { ``3``, ``5` `};``    ` `    ``System.out.println(FindMinMoves(A, B));``}``}` `// This code is contributed by _saurabh_jaiswal`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum number``# of operation required to satisfy the``# given conditions``def` `FindMinMoves(A, B):``    ` `    ``n ``=` `len``(A)``    ``m ``=` `len``(B)` `    ``# sort the array A and B in the``    ``# ascending and descending order``    ``A.sort()``    ``B.sort(reverse ``=` `True``)``    ``ans ``=` `0` `    ``# Iterate over both the arrays``    ``i ``=` `0``    ` `    ``for` `i ``in` `range``(``min``(m, n)):` `        ``# Add the difference to the``        ``# variable answer``        ``if` `A[i] < B[i]:``            ``ans ``+``=` `(B[i] ``-` `A[i])` `    ``# Return the resultant operations``    ``return` `ans` `# Driver Code``A ``=` `[ ``2``, ``3` `]``B ``=` `[ ``3``, ``5` `]` `print``(FindMinMoves(A, B))` `# This code is contributed by gfgking`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Comparator function``public` `static` `bool` `cmp(``int` `a, ``int` `b)``{``    ``return` `a > b;``}` `// Function to find the minimum number``// of operation required to satisfy the``// given conditions``public` `static` `int` `FindMinMoves(``int``[] A, ``int``[] B)``{``    ``int` `n, m;``    ``n = A.Length;``    ``m = B.Length;` `    ``// Sort the array A and B in the``    ``// ascending and descending order``    ``Array.Sort(A);``    ``Array.Sort(B);` `    ``int` `ans = 0;` `    ``// Iterate over both the arrays``    ``for``(``int` `i = 0;``            ``i < Math.Min(m, n) && A[i] < B[i]; ++i)``    ``{``        ` `        ``// Add the difference to the``        ``// variable answer``        ``ans += (B[i] - A[i]);``    ``}` `    ``// Return the resultant operations``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int``[] A = { 2, 3 };``    ``int``[] B = { 3, 5 };``    ` `    ``Console.Write(FindMinMoves(A, B));``}``}` `// This code is contributed by target_2.`

## Javascript

 ``

Output:

`3`

Time Complexity: O(K*log K), where the value of K is max(N, M).
Auxiliary Space: O(1)