Related Articles
Minimize cost of increments or decrements such that same indexed elements become multiple of each other
• Last Updated : 03 Mar, 2021

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 ith 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 by 1 (3 + 1 = 4) makes it multiple of B(= 4).
Incrementing A by 2 (6 + 2 = 8) makes it a multiple of B(= 8).
Decrementing B by 1 (13 – 1 = 12) makes it a multiple of A(= 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++

 `// C++ program for the above approach``#include ``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);` `    ``cout << MinimumCost(A, B, N);` `    ``return` `0;``}`

## Java

 `// 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`

## Python3

 `# 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#

 `// 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`
Output:
`4`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up