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 = 20 

Input: 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>

Output

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>

Output

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)