Minimum operations of given type to make all elements of a matrix equal
Given an integer K and a matrix of N rows and M columns, the task is to find the minimum number of operations required to make all the elements of the matrix equal. In a single operation, K can be added to or subtracted from any element of the matrix. Print -1 if it is impossible to do so.
Examples:
Input: mat[][] = {{2, 4}, {22, 24}}, K = 2
Output: 20
Explanation: mat[0][0] = 2 + (10 * K) = 22 … 10 operations
mat[0][1] = 4 + (9 * K) = 22 … 9 operations
mat[1][0] = 22 … No operation
mat[1][1] = 24 – K = 22 … 1 operations
10 + 9 + 1 = 20Input: mat[][] = {
Explanation: {3, 63, 42},
{18, 12, 12},
{15, 21, 18},
{33, 84, 24}},
K = 3
Output: 63
Approach:
- Since we are only allowed to add or subtract K from any element, we can easily infer that the mod of all the elements with K should be equal because x % K = (x + K) % K = (x – K) % K.
- If that is not the case, simply print -1.
- Otherwise, sort all the elements of the matrix in non-decreasing order and find the median of the sorted elements.
- The minimum number of steps would occur if we convert all the elements to equal to the median.
- Calculate these steps and print the result.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std; // Function to return the minimum // number of operations required int minOperations( int n, int m, int k, vector<vector< int > >& matrix) { // Create another array to // store the elements of matrix vector< int > arr(n * m, 0); int mod = matrix[0][0] % k; for ( int i = 0; i < n; ++i) { for ( int j = 0; j < m; ++j) { arr[i * m + j] = matrix[i][j]; // If not possible if (matrix[i][j] % k != mod) { return -1; } } } // Sort the array to get median sort(arr.begin(), arr.end()); int median = arr[(n * m) / 2]; // To count the minimum operations int minOperations = 0; for ( int i = 0; i < n * m; ++i) minOperations += abs (arr[i] - median) / k; // If there are even elements, then there // are two medians. We consider the best // of two as answer. if ((n * m) % 2 == 0) { int median2 = arr[((n * m) / 2) - 1]; int minOperations2 = 0; for ( int i = 0; i < n * m; ++i) minOperations2 += abs (arr[i] - median2) / k; minOperations = min(minOperations, minOperations2); } // Return minimum operations required return minOperations; } // Driver code int main() { vector<vector< int > > matrix = { { 2, 4, 6 }, { 8, 10, 12 }, { 14, 16, 18 }, { 20, 22, 24 } }; int n = matrix.size(); int m = matrix[0].size(); int k = 2; cout << minOperations(n, m, k, matrix); return 0; } |
Java
// Java implementation of the approach import java.util.*; class GFG { // Function to return the minimum // number of operations required static int minOperations( int n, int m, int k, int matrix[][]) { // Create another array to // store the elements of matrix int [] arr = new int [n * m]; int mod = matrix[ 0 ][ 0 ] % k; for ( int i = 0 ; i < n; ++i) { for ( int j = 0 ; j < m; ++j) { arr[i * m + j] = matrix[i][j]; // If not possible if (matrix[i][j] % k != mod) { return - 1 ; } } } // Sort the array to get median Arrays.sort(arr); int median = arr[(n * m) / 2 ]; // To count the minimum operations int minOperations = 0 ; for ( int i = 0 ; i < n * m; ++i) minOperations += Math.abs(arr[i] - median) / k; // If there are even elements, then there // are two medians. We consider the best // of two as answer. if ((n * m) % 2 == 0 ) { int median2 = arr[((n * m) / 2 ) - 1 ]; int minOperations2 = 0 ; for ( int i = 0 ; i < n * m; ++i) minOperations2 += Math.abs(arr[i] - median2) / k; minOperations = Math.min(minOperations, minOperations2); } // Return minimum operations required return minOperations; } // Driver code public static void main(String[] args) { int matrix[][] = { { 2 , 4 , 6 }, { 8 , 10 , 12 }, { 14 , 16 , 18 }, { 20 , 22 , 24 } }; int n = matrix.length; int m = matrix[ 0 ].length; int k = 2 ; System.out.println(minOperations(n, m, k, matrix)); } } // This code is contributed by ihritik |
Python3
# Python3 implementation of the approach # Function to return the minimum # number of operations required def minOperations(n, m, k, matrix): # Create another array to store the # elements of matrix arr = [ 0 ] * (n * m) mod = matrix[ 0 ][ 0 ] % k for i in range ( 0 , n): for j in range ( 0 , m): arr[i * m + j] = matrix[i][j] # If not possible if matrix[i][j] % k ! = mod: return - 1 # Sort the array to get median arr.sort() median = arr[(n * m) / / 2 ] # To count the minimum operations minOperations = 0 for i in range ( 0 , n * m): minOperations + = abs (arr[i] - median) / / k # If there are even elements, then there # are two medians. We consider the best # of two as answer. if (n * m) % 2 = = 0 : median2 = arr[((n * m) / / 2 ) - 1 ] minOperations2 = 0 for i in range ( 0 , n * m): minOperations2 + = abs (arr[i] - median2) / / k minOperations = min (minOperations, minOperations2) # Return minimum operations required return minOperations # Driver code if __name__ = = "__main__" : matrix = [[ 2 , 4 , 6 ], [ 8 , 10 , 12 ], [ 14 , 16 , 18 ], [ 20 , 22 , 24 ]] n = len (matrix) m = len (matrix[ 0 ]) k = 2 print (minOperations(n, m, k, matrix)) # This code is contributed by Rituraj Jain |
C#
// C# implementation of the approach using System; class GFG { // Function to return the minimum // number of operations required static int minOperations( int n, int m, int k, int [, ] matrix) { // Create another array to // store the elements of matrix int [] arr = new int [n * m]; int mod = matrix[0, 0] % k; for ( int i = 0; i < n; ++i) { for ( int j = 0; j < m; ++j) { arr[i * m + j] = matrix[i, j]; // If not possible if (matrix[i, j] % k != mod) { return -1; } } } // Sort the array to get median Array.Sort(arr); int median = arr[(n * m) / 2]; // To count the minimum operations int minOperations = 0; for ( int i = 0; i < n * m; ++i) minOperations += Math.Abs(arr[i] - median) / k; // If there are even elements, then there // are two medians. We consider the best // of two as answer. if ((n * m) % 2 == 0) { int median2 = arr[((n * m) / 2) - 1]; int minOperations2 = 0; for ( int i = 0; i < n * m; ++i) minOperations2 += Math.Abs(arr[i] - median2) / k; minOperations = Math.Min(minOperations, minOperations2); } // Return minimum operations required return minOperations; } // Driver code public static void Main() { int [, ] matrix = { { 2, 4, 6 }, { 8, 10, 12 }, { 14, 16, 18 }, { 20, 22, 24 } }; int n = matrix.GetLength(0); int m = matrix.GetLength(1); int k = 2; Console.WriteLine(minOperations(n, m, k, matrix)); } } // This code is contributed by Ryuga |
Javascript
<script> // Javascript implementation of the approach // Function to return the minimum // number of operations required function minOperations(n, m, k, matrix) { // Create another array to // store the elements of matrix let arr = new Array(n * m); arr.fill(0); let mod = matrix[0][0] % k; for (let i = 0; i < n; ++i) { for (let j = 0; j < m; ++j) { arr[i * m + j] = matrix[i][j]; // If not possible if (matrix[i][j] % k != mod) { return -1; } } } // Sort the array to get median arr.sort( function (a, b){ return a - b}); let median = arr[parseInt((n * m) / 2, 10)]; // To count the minimum operations let minOperations = 0; for (let i = 0; i < n * m; ++i) minOperations += parseInt(Math.abs(arr[i] - median) / k, 10); // If there are even elements, then there // are two medians. We consider the best // of two as answer. if ((n * m) % 2 == 0) { let median2 = arr[parseInt((n * m) / 2, 10)]; let minOperations2 = 0; for (let i = 0; i < n * m; ++i) minOperations2 += parseInt(Math.abs(arr[i] - median2) / k, 10); minOperations = Math.min(minOperations, minOperations2); } // Return minimum operations required return minOperations; } // Driver code let matrix = [ [ 2, 4, 6 ], [ 8, 10, 12 ], [ 14, 16, 18 ], [ 20, 22, 24 ] ]; let n = 4; let m = 3; let k = 2; document.write(minOperations(n, m, k, matrix)); // This code is contributed by mukesh07. </script> |
36
Minimum operations of given type to make all elements of a Matrix equal with negative numbers
Implementation:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std; // Function to return the minimum // number of operations required int minOperations( int n, int m, int k, vector<vector< int > >& matrix) { // Create another array to // store the elements of matrix vector< int > arr; int mod; // will not work for negative elements, so .. // adding this if (matrix[0][0] < 0) { mod = k - ( abs (matrix[0][0]) % k); } else { mod = matrix[0][0] % k; } for ( int i = 0; i < n; ++i) { for ( int j = 0; j < m; ++j) { arr.push_back(matrix[i][j]); // adding this to handle negative elements too . int val = matrix[i][j]; if (val < 0) { int res = k - ( abs (val) % k); if (res != mod) { return -1; } } else { int foo = matrix[i][j]; if (foo % k != mod) { return -1; } } } } // Sort the array to get median sort(arr.begin(), arr.end()); int median = arr[(n * m) / 2]; // To count the minimum operations int minOperations = 0; for ( int i = 0; i < n * m; ++i) minOperations += abs (arr[i] - median) / k; // If there are even elements, then there // are two medians. We consider the best // of two as answer. if ((n * m) % 2 == 0) { // changed here as in case of even elements there // will be 2 medians int median2 = arr[((n * m) / 2) - 1]; int minOperations2 = 0; for ( int i = 0; i < n * m; ++i) minOperations2 += abs (arr[i] - median2) / k; minOperations = min(minOperations, minOperations2); } // Return minimum operations required return minOperations; } // Driver code int main() { vector<vector< int > > matrix = { { 2, 4, 6 }, { 8, 10, 12 }, { 14, 16, 18 }, { 20, 22, 24 } }; int n = matrix.size(); int m = matrix[0].size(); int k = 2; cout << minOperations(n, m, k, matrix); return 0; } |
Java
// Java implementation of the approach import java.util.*; class GFG { // Function to return the minimum // number of operations required public static int minOperations( int n, int m, int k, int matrix[][]) { // Create another array to // store the elements of matrix Vector<Integer> arr = new Vector<>(); int mod; // will not work for negative elements, so .. // adding this if (matrix[ 0 ][ 0 ] < 0 ) { mod = k - (Math.abs(matrix[ 0 ][ 0 ]) % k); } else { mod = matrix[ 0 ][ 0 ] % k; } for ( int i = 0 ; i < n; ++i) { for ( int j = 0 ; j < m; ++j) { arr.add(matrix[i][j]); // adding this to handle // negative elements too . int val = matrix[i][j]; if (val < 0 ) { int res = k - (Math.abs(val) % k); if (res != mod) { return - 1 ; } } else { int foo = matrix[i][j]; if (foo % k != mod) { return - 1 ; } } } } // Sort the array to get median Collections.sort(arr); int median = arr.get((n * m) / 2 ); // To count the minimum operations int minOperations = 0 ; for ( int i = 0 ; i < n * m; ++i) minOperations += Math.abs(arr.get(i) - median) / k; // If there are even elements, then there // are two medians. We consider the best // of two as answer. if ((n * m) % 2 == 0 ) { // changed here as in case of // even elements there will be 2 medians int median2 = arr.get(((n * m) / 2 ) - 1 ); int minOperations2 = 0 ; for ( int i = 0 ; i < n * m; ++i) minOperations2 += Math.abs(arr.get(i) - median2) / k; minOperations = Math.min(minOperations, minOperations2); } // Return minimum operations required return minOperations; } // Driver code public static void main(String[] args) { int matrix[][] = { { 2 , 4 , 6 }, { 8 , 10 , 12 }, { 14 , 16 , 18 }, { 20 , 22 , 24 } }; int n = matrix.length; int m = matrix[ 0 ].length; int k = 2 ; System.out.println(minOperations(n, m, k, matrix)); } } // This code is contributed by divyesh072019 |
Python3
# Python3 implementation of the # above approach # Function to return the minimum # number of operations required def minOperations(n, m, k, matrix): # Create another array to # store the elements of # matrix arr = [] # will not work for negative # elements, so .. adding this if (matrix[ 0 ][ 0 ] < 0 ): mod = k - ( abs (matrix[ 0 ][ 0 ]) % k) else : mod = matrix[ 0 ][ 0 ] % k for i in range (n): for j in range (m): arr.append(matrix[i][j]) # adding this to handle # negative elements too . val = matrix[i][j] if (val < 0 ): res = k - ( abs (val) % k) if (res ! = mod): return - 1 else : foo = matrix[i][j] if (foo % k ! = mod): return - 1 # Sort the array to get median arr.sort() median = arr[(n * m) / / 2 ] # To count the minimum # operations minOperations = 0 for i in range (n * m): minOperations + = abs (arr[i] - median) / / k # If there are even elements, # then there are two medians. # We consider the best of two # as answer. if ((n * m) % 2 = = 0 ): # changed here as in case of # even elements there will be # 2 medians median2 = arr[((n * m) / / 2 ) - 1 ] minOperations2 = 0 for i in range (n * m): minOperations2 + = abs (arr[i] - median2) / k minOperations = min (minOperations, minOperations2) # Return minimum operations required return minOperations # Driver code if __name__ = = "__main__" : matrix = [[ 2 , 4 , 6 ], [ 8 , 10 , 12 ], [ 14 , 16 , 18 ], [ 20 , 22 , 24 ]] n = len (matrix) m = len (matrix[ 0 ]) k = 2 print (minOperations(n, m, k, matrix)) # This code is contributed by Chitranayal |
C#
// C# implementation of the approach using System; using System.Collections.Generic; class GFG { // Function to return the minimum // number of operations required static int minOperations( int n, int m, int k, List<List< int > > matrix) { // Create another array to // store the elements of matrix List< int > arr = new List< int >(); int mod; // will not work for negative elements, so .. // adding this if (matrix[0][0] < 0) { mod = k - (Math.Abs(matrix[0][0]) % k); } else { mod = matrix[0][0] % k; } for ( int i = 0; i < n; ++i) { for ( int j = 0; j < m; ++j) { arr.Add(matrix[i][j]); // adding this to handle negative elements // too . int val = matrix[i][j]; if (val < 0) { int res = k - (Math.Abs(val) % k); if (res != mod) { return -1; } } else { int foo = matrix[i][j]; if (foo % k != mod) { return -1; } } } } // Sort the array to get median arr.Sort(); int median = arr[(n * m) / 2]; // To count the minimum operations int minOperations = 0; for ( int i = 0; i < n * m; ++i) minOperations += Math.Abs(arr[i] - median) / k; // If there are even elements, then there // are two medians. We consider the best // of two as answer. if ((n * m) % 2 == 0) { // changed here as in case of // even elements there will be 2 medians int median2 = arr[((n * m) / 2) - 1]; int minOperations2 = 0; for ( int i = 0; i < n * m; ++i) minOperations2 += Math.Abs(arr[i] - median2) / k; minOperations = Math.Min(minOperations, minOperations2); } // Return minimum operations required return minOperations; } static void Main() { List<List< int > > matrix = new List<List< int > >{ new List< int >{ 2, 4, 6 }, new List< int >{ 8, 10, 12 }, new List< int >{ 14, 16, 18 }, new List< int >{ 20, 22, 24 }, }; int n = matrix.Count; int m = matrix[0].Count; int k = 2; Console.Write(minOperations(n, m, k, matrix)); } } // This code is contributed by divyeshrabadiya07. |
Javascript
<script> // Javascript implementation of the approach // Function to return the minimum // number of operations required function minOperations(n,m,k,matrix) { // Create another array to // store the elements of matrix let arr = []; let mod; // will not work for negative elements, so .. // adding this if (matrix[0][0] < 0) { mod = k - (Math.abs(matrix[0][0]) % k); } else { mod = matrix[0][0] % k; } for (let i = 0; i < n; ++i) { for (let j = 0; j < m; ++j) { arr.push(matrix[i][j]); // adding this to handle // negative elements too . let val = matrix[i][j]; if (val < 0) { let res = k - (Math.abs(val) % k); if (res != mod) { return -1; } } else { let foo = matrix[i][j]; if (foo % k != mod) { return -1; } } } } // Sort the array to get median arr.sort( function (a,b){ return a-b;}); let median = arr[(n * m) / 2]; // To count the minimum operations let minOperations = 0; for (let i = 0; i < n * m; ++i) minOperations += Math.abs(arr[i] - median) / k; // If there are even elements, then there // are two medians. We consider the best // of two as answer. if ((n * m) % 2 == 0) { // changed here as in case of // even elements there will be 2 medians let median2 = arr[((n * m) / 2) - 1]; let minOperations2 = 0; for (let i = 0; i < n * m; ++i) minOperations2 += Math.abs(arr[i] - median2) / k; minOperations = Math.min(minOperations, minOperations2); } // Return minimum operations required return minOperations; } // Driver code let matrix = [[2, 4, 6], [8, 10, 12], [14, 16, 18], [20, 22, 24]]; let n = matrix.length; let m = matrix[0].length; let k = 2; document.write(minOperations(n, m, k, matrix)); // This code is contributed by rag2127 </script> |
36
Complexity Analysis:
- Time Complexity: O(n*m* log(n*m)), where n is the number of rows and m is the number of columns of the given matrix.
- Auxiliary Space: O(n*m)
Please Login to comment...