Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Last Updated : 29 Apr, 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[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++




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



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



<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>
Output: 
4
 
Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
Check if an array element is concatenation of two elements from another array
Next

Find a triplet (i, j, k) from an array such that i < j < k and arr[i] < arr[j] > arr[k]
Recommended Articles
Page :
Bitwise XOR of same indexed array elements after rearranging an array to make XOR of same indexed elements of two arrays equal
05, Aug 21
Minimize subarray increments/decrements required to reduce all array elements to 0
17, Sep 20
Minimize increments or decrements required to make sum and product of array elements non-zero
09, Nov 20
Minimize increments or decrements by 2 to convert given value to a perfect square
29, Oct 20
Minimize decrements to make each Array elements same or 0
03, Mar 22
Find K that requires minimum increments or decrements of array elements to obtain a sequence of increasing powers of K
19, Oct 20
Minimum increments or decrements by D required to make all array elements equal
13, Jan 21
Minimum increments or decrements by 1 required to make all array elements in AP
21, Jul 21
Minimum increments or decrements required to signs of prefix sum array elements alternating
05, Aug 21
Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
03, Jan 21
Count pairs of same parity indexed elements with same MSD after replacing each element by the sum of maximum digit * A and minimum digits * B
08, Mar 21
Check if all characters of a string can be made equal by increments or decrements
05, May 21
Maximize GCD of an array by increments or decrements by K
26, Feb 21
Minimum increments or decrements required to convert a sorted array into a power sequence
17, Mar 21
Minimize cost by splitting given Array into subsets of size K and adding highest K/2 elements of each subset into cost
26, Jan 22
Minimize cost to make X and Y equal by given increments
15, Jan 21
Minimum increments done in Array such that arr[i] can make all other elements equal
18, Nov 21
Minimize cost to reach bottom right from top left corner of Matrix with given separate cost for each move
11, Jan 22
Minimize the Sum of all the subarrays made up of the products of same-indexed elements
07, Aug 20
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
31, May 21
Minimize sum of absolute differences of same-indexed elements of two given arrays by at most one replacement
16, May 21
Minimize count of increments of each element of subarrays required to make Array non-increasing
31, Aug 20
Minimize subtraction followed by increments of adjacent elements required to make all array elements equal
22, Mar 21
Maximize product of same-indexed elements of same size subsequences
09, Jun 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
subhammahato348
@subhammahato348
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!