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

Last Updated : 17 Feb, 2022

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)

Previous
Next