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