Minimum operations to make all elements equal using the second array

Given two arrays A[] and B[] both having N elements. Find the minimum number of operations to make all elements of A equal to the second array B. An operation comprises of:

A[i] = A[i] - B[i], 0 <= i <= n-1

Note: If it’s not possible to make array elements equal print -1.

Examples:

Input: A[] = {5, 7, 10, 5, 15}, B[] = {2, 2, 1, 3, 5}
Output: 8
Explanation:
Following are the operations:
1) Choosing index 1 -> 5 5 10 5 15
2) Choosing index 2 -> 5 5 9 5 15
3) Choosing index 2 -> 5 5 8 5 15
4) Choosing index 2 -> 5 5 7 5 15
5) Choosing index 2 -> 5 5 6 5 15
6) Choosing index 2 -> 5 5 5 5 15
7) Choosing index 4 -> 5 5 5 5 10
8) Choosing index 4 -> 5 5 5 5 5

Input: A[] = {3, 5, 8, 2}, B[] = {1, 2, 1, 1}
Output: 12

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

It can be observed that the maximum possible value if all elements of A can be made equal is the minimum element of A.
So we can iterate over the final value x, when all elements of A become equal. Using above observation – 0 <= x <= min(A[i]). For each x, traverse A and check whether A[i] can be made equal to x using B[i] :
```
A[i] - k*B[i] = x
Take mod with B[i] on both sides
A[i] %B[i] = x %B[i]  ->  
must be satisfied for A[i] to be converted to x
```
If condition is satisfied, then number of operations required for this element = (A[i] – x)/B[i]

Below is the implementation of the above approach:

C++

// C++ implementation to find the 
// minimum operations make all elements  
// equal using the second array 
  
#include <bits/stdc++.h> 
  
using namespace std; 
  
// Function to find the minimum  
// operations required to make 
// all elements of the array equal 
int minOperations(int a[], int b[], int n) 
{ 
    // Minimum element of A[] 
    int minA = *min_element(a, a + n); 
  
    // Traverse through all final values 
    for (int x = minA; x >= 0; x--) { 
          
        // Variable indicating  
        // whether all elements 
        // can be converted to x or not 
        bool check = 1; 
  
        // Total operations 
        int operations = 0; 
          
        // Traverse through  
        // all array elements 
        for (int i = 0; i < n; i++) { 
            if (x % b[i] == a[i] % b[i]) { 
                operations +=  
                    (a[i] - x) / b[i]; 
            } 
  
            // All elements can't  
            // be converted to x 
            else { 
                check = 0; 
                break; 
            } 
        } 
        if (check) 
            return operations; 
    } 
    return -1; 
} 
  
// Driver Code 
int main() 
{ 
    int N = 5; 
    int A[N] = { 5, 7, 10, 5, 15 }; 
    int B[N] = { 2, 2, 1, 3, 5 }; 
  
    cout << minOperations(A, B, N); 
    return 0; 
} 

Java

// Java implementation to find the 
// minimum operations make all elements  
// equal using the second array 
import java.util.*; 
class GFG{ 
  
// Function to find the minimum  
// operations required to make 
// all elements of the array equal 
static int minOperations(int a[], int b[], int n) 
{ 
    // Minimum element of A[] 
    int minA = Arrays.stream(a).min().getAsInt(); 
  
    // Traverse through all final values 
    for (int x = minA; x >= 0; x--)  
    { 
          
        // Variable indicating  
        // whether all elements 
        // can be converted to x or not 
        boolean check = true; 
  
        // Total operations 
        int operations = 0; 
          
        // Traverse through  
        // all array elements 
        for (int i = 0; i < n; i++)  
        { 
            if (x % b[i] == a[i] % b[i])  
            { 
                operations += (a[i] - x) / b[i]; 
            } 
  
            // All elements can't  
            // be converted to x 
            else 
            { 
                check = false; 
                break; 
            } 
        } 
        if (check) 
            return operations; 
    } 
    return -1; 
} 
  
// Driver Code 
public static void main(String[] args) 
{ 
    int N = 5; 
    int A[] = { 5, 7, 10, 5, 15 }; 
    int B[] = { 2, 2, 1, 3, 5 }; 
  
    System.out.print(minOperations(A, B, N)); 
} 
} 
  
// This code is contributed by AbhiThakur 

C#

// C# implementation to find the 
// minimum operations make all elements  
// equal using the second array 
using System; 
using System.Linq; 
  
class GFG{ 
  
// Function to find the minimum  
// operations required to make 
// all elements of the array equal 
static int minOperations(int []a, int []b, int n) 
{ 
      
    // Minimum element of A[] 
    int minA = a.Max(); 
  
    // Traverse through all final values 
    for(int x = minA; x >= 0; x--)  
    { 
         
       // Variable indicating  
       // whether all elements 
       // can be converted to x or not 
       bool check = true; 
         
       // Total operations 
       int operations = 0; 
         
       // Traverse through  
       // all array elements 
       for(int i = 0; i < n; i++)  
       { 
          if (x % b[i] == a[i] % b[i])  
          { 
              operations += (a[i] - x) / b[i]; 
          } 
            
          // All elements can't  
          // be converted to x 
          else
          { 
              check = false; 
              break; 
          } 
       } 
       if (check) 
           return operations; 
    } 
    return -1; 
} 
  
// Driver Code 
public static void Main(string[] args) 
{ 
    int N = 5; 
    int []A = { 5, 7, 10, 5, 15 }; 
    int []B = { 2, 2, 1, 3, 5 }; 
  
    Console.WriteLine(minOperations(A, B, N)); 
} 
} 
  
// This code is contributed by SoumikMondal 

Output:

Time Complexity: O(N * min(A_i))

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

C#

Recommended Posts: