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:
- Increase the value of A[1] by 1 modifies the array A[] = {3, 3}.
- Decrease the value of B[2] by 1 modifies the array B[] = {3, 4}.
- 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:
- Sort the array A[] in increasing order.
- Sort the array B[] in decreasing order.
- Traverse both of the arrays while A[i] < B[i], in order to make all elements of the arrays A[] and B[], till index i, equal, say x, then the total number of operations is given by:
=> (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++ program for the above approach #include <bits/stdc++.h> 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<ll> A, vector<ll> 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<ll> A = { 2, 3 };
vector<ll> B = { 3, 5 };
cout << FindMinMoves(A, B);
return 0;
} |
// 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 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# 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. |
<script> // JavaScript program for the above approach
// Function to find the minimum number
// of operation required to satisfy the
// given conditions
function FindMinMoves(A, B)
{
let n, m;
n = A.length;
m = B.length;
// sort the array A and B in the
// ascending and descending order
A.sort( function (a, b) { return a - b; });
B.sort( function (a, b) { return b - a; });
let ans = 0;
// Iterate over both the arrays
for (let 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
let A = [2, 3];
let B = [3, 5];
document.write(FindMinMoves(A, B));
// This code is contributed by Potta Lokesh
</script>
|
3
Time Complexity: O(K*log K), where the value of K is max(N, M).
Auxiliary Space: O(1)