Minimize cost of increments or decrements such that same indexed elements become multiple of each other

Given two arrays A[] and B[] consisting of N integers, the task is to minimize the total cost of incrementing or decrementing array elements by 1 such that for every i^th element, either A[i] is a multiple of B[i] or vice-versa.

Examples:

Input: A[] = {3, 6, 3}, B[] = {4, 8, 13}
Output: 4
Explanation:
Incrementing A[0] by 1 (3 + 1 = 4) makes it multiple of B[0](= 4).
Incrementing A[1] by 2 (6 + 2 = 8) makes it a multiple of B[1](= 8).
Decrementing B[2] by 1 (13 - 1 = 12) makes it a multiple of A[2](= 3).
Therefore, the total cost = 1 + 2 + 1 = 4.

Input: A[] = {13, 2, 31, 7}, B[] = {6, 8, 11, 3}
Output: 4

Approach: The given problem can be solved greedily. Follow the steps below to solve the problem:

• Initialize a variable, say cost, to store the required minimum cost.
• Traverse both the arrays A[] and B[] simultaneously and perform the following steps:
  • Case 1: Find the cost to update A[i] to make it a multiple of B[i], which is the minimum of (B[i] % A[i]) and (A[i] - B[i] % A[i]).
  • Case 2: Find the cost to update B[i] to make it a multiple of A[i], which is the minimum of (A[i] % B[i]) and (B[i] - A[i] % B[i]).
  • Add the minimum of the above two costs to the variable cost for each array element.
• After completing the above steps, print the value of cost as the result.

Below is the implementation of the above approach:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the minimum cost to
// make A[i] multiple of B[i] or
// vice-versa for every array element
int MinimumCost(int A[], int B[],
                int N)
{
    // Stores the minimum cost
    int totalCost = 0;

    // Traverse the array
    for (int i = 0; i < N; i++) {

        // Case 1: Update A[i]
        int mod_A = B[i] % A[i];
        int totalCost_A = min(mod_A,
                              A[i] - mod_A);

        // Case 2: Update B[i]
        int mod_B = A[i] % B[i];
        int totalCost_B = min(mod_B,
                              B[i] - mod_B);

        // Add the minimum of
        // the above two cases
        totalCost += min(totalCost_A,
                         totalCost_B);
    }

    // Return the resultant cost
    return totalCost;
}

// Driver Code
int main()
{
    int A[] = { 3, 6, 3 };
    int B[] = { 4, 8, 13 };
    int N = sizeof(A) / sizeof(A[0]);

    cout << MinimumCost(A, B, N);

    return 0;
}

// Java program for the above approach
import java.io.*;

class GFG{

// Function to find the minimum cost to
// make A[i] multiple of B[i] or
// vice-versa for every array element
static int MinimumCost(int A[], int B[], int N)
{
    
    // Stores the minimum cost
    int totalCost = 0;

    // Traverse the array
    for(int i = 0; i < N; i++) 
    {
        
        // Case 1: Update A[i]
        int mod_A = B[i] % A[i];
        int totalCost_A = Math.min(mod_A, 
                            A[i] - mod_A);

        // Case 2: Update B[i]
        int mod_B = A[i] % B[i];
        int totalCost_B = Math.min(mod_B, 
                            B[i] - mod_B);

        // Add the minimum of
        // the above two cases
        totalCost += Math.min(totalCost_A, 
                              totalCost_B);
    }

    // Return the resultant cost
    return totalCost;
}

// Driver Code
public static void main(String[] args)
{
    int A[] = { 3, 6, 3 };
    int B[] = { 4, 8, 13 };
    int N = A.length;

    System.out.print(MinimumCost(A, B, N));
}
}

// This code is contributed by souravmahato348

# Python program for the above approach

# Function to find the minimum cost to
# make A[i] multiple of B[i] or
# vice-versa for every array element
def MinimumCost(A, B, N):
    
    # Stores the minimum cost
    totalCost = 0
    
    # Traverse the array
    for i in range(N):
        
        # Case 1: Update A[i]
        mod_A = B[i] % A[i]
        totalCost_A = min(mod_A, A[i] - mod_A)
        
        # Case 2: Update B[i]
        mod_B = A[i] % B[i]
        totalCost_B = min(mod_B, B[i] - mod_B)
        
        # Add the minimum of
        # the above two cases
        totalCost += min(totalCost_A, totalCost_B)
        
    # Return the resultant cost
    return totalCost

# Driver Code
A = [3, 6, 3]
B =  [4, 8, 13]
N = len(A)

print(MinimumCost(A, B, N))

# This code is contributed by shubhamsingh10

// C# program for the above approach
using System;

class GFG {

    // Function to find the minimum cost to
    // make A[i] multiple of B[i] or
    // vice-versa for every array element
    static int MinimumCost(int[] A, int[] B, int N)
    {

        // Stores the minimum cost
        int totalCost = 0;

        // Traverse the array
        for (int i = 0; i < N; i++) {

            // Case 1: Update A[i]
            int mod_A = B[i] % A[i];
            int totalCost_A = Math.Min(mod_A, A[i] - mod_A);

            // Case 2: Update B[i]
            int mod_B = A[i] % B[i];
            int totalCost_B = Math.Min(mod_B, B[i] - mod_B);

            // Add the minimum of
            // the above two cases
            totalCost += Math.Min(totalCost_A, totalCost_B);
        }

        // Return the resultant cost
        return totalCost;
    }

    // Driver Code
    public static void Main()
    {
        int[] A = { 3, 6, 3 };
        int[] B = { 4, 8, 13 };
        int N = A.Length;

        Console.Write(MinimumCost(A, B, N));
    }
}

// This code is contributed by rishavmahato348

<script>
// javascript program for the above approach

    // Function to find the minimum cost to
    // make A[i] multiple of B[i] or
    // vice-versa for every array element
    function MinimumCost(A , B , N) {

        // Stores the minimum cost
        var totalCost = 0;

        // Traverse the array
        for (i = 0; i < N; i++) {

            // Case 1: Update A[i]
            var mod_A = B[i] % A[i];
            var totalCost_A = Math.min(mod_A, A[i] - mod_A);

            // Case 2: Update B[i]
            var mod_B = A[i] % B[i];
            var totalCost_B = Math.min(mod_B, B[i] - mod_B);

            // Add the minimum of
            // the above two cases
            totalCost += Math.min(totalCost_A, totalCost_B);
        }

        // Return the resultant cost
        return totalCost;
    }

    // Driver Code
    
        var A = [ 3, 6, 3 ];
        var B = [ 4, 8, 13 ];
        var N = A.length;

        document.write(MinimumCost(A, B, N));

// This code contributed by aashish1995
</script>

4

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