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:

• 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)

rohitpal210

Follow

Improve

Article Tags :

• Misc
• Greedy
• Sorting
• Mathematical
• DSA
• Arrays

+2 More

Practice Tags :

• Arrays
• Greedy
• Mathematical
• Misc
• Sorting

+1 More