GeeksforGeeks App
Open App
Browser
Continue

# Minimum increments required to make given matrix palindromic

Given a matrix M[][] of dimensions N * M, the task is to find the minimum number of increments of matrix elements by 1 required to convert the matrix to a palindromic matrix.

A palindrome matrix is a matrix in which every row and column is a palindrome

Example:

Input: N = 4, M = 2, arr[][]={{5, 3}, {3, 5}, {5, 3}, {3, 5}}
Output: 8
Explanation: The palindromic matrix will be arr[][] = {{5, 5}, {5, 5}, {5, 5}, {5, 5}}

Input: N = 3, M = 3, arr[][]={{1, 2, 1}, {3, 4, 1}, {1, 2, 1}}
Output: 2
Explanation:
The palindromic matrix will be arr[][] = {{1, 2, 1}, {3, 4, 3}, {1, 2, 1}}

Approach: If the value of arr[0][0] is equal X, then values of arr[M-1][0], arr[0][M-1], and arr[N-1][M-1] must also be equal to X by the palindrome property. A similar property holds for all the elements arr[i][j], arr[N – i – 1][j], arr[N – i – 1][M – j – 1], arr[i][M – j – 1] as well. Therefore, the problem reduces to finding the number that can be obtained from the concerned quadruples with minimum increments. Follow the steps below to solve the problem:

1. Divide the matrix into 4 quadrants. Traverse over the matrix from (0, 0) index to (((N + 1) / 2)-1, ((M + 1) / 2)-1) (Only in the first quadrant).
2. For each index (i, j) store (i, j), (N – i – 1, j), (N – i – 1, M – j – 1), (i, M – j – 1) indexes in a set so that only unique indexes will be present in the set.
3. Then store the elements present in those unique indexes in vector values and evaluate the maximum in this vector.
4. Now add the difference between the maximum value and the rest of the elements of the values vector and update the ans.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to evaluate minimum number``// of operation required to convert``// the matrix to a palindrome matrix``int` `palindromeMatrix(``int` `N, ``int` `M, vector > arr)``{``    ``// Variable to store number``    ``// of operations required``    ``int` `ans = 0;` `    ``// Iterate over the first``    ``// quadrant of the matrix``    ``for` `(``int` `i = 0; i < (N + 1) / 2; i++) {` `        ``for` `(``int` `j = 0; j < (M + 1) / 2; j++) {` `            ``// Store positions of all four``            ``// values from four quadrants``            ``set > s;``            ``s.insert({ i, j });``            ``s.insert({ i, M - j - 1 });``            ``s.insert({ N - i - 1, j });``            ``s.insert({ N - i - 1, M - j - 1 });` `            ``// Store the values having``            ``// unique indexes``            ``vector<``int``> values;``            ``for` `(pair<``int``, ``int``> p : s) {` `                ``values.push_back(``                    ``arr[p.first][p.second]);``            ``}` `            ``// Largest value in the values vector``            ``int` `max = *max_element(``                ``values.begin(),``                ``values.end());` `            ``// Evaluate minimum increments``            ``// required to make all vector``            ``// elements equal``            ``for` `(``int` `k = 0; k < values.size(); k++) {` `                ``ans += max - values[k];``            ``}``        ``}``    ``}` `    ``// Print the answer``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``int` `N = 3, M = 3;``    ``vector > arr``        ``= { { 1, 2, 1 },``            ``{ 3, 4, 1 },``            ``{ 1, 2, 1 } };` `    ``// Function Call``    ``palindromeMatrix(N, M, arr);` `    ``return` `0;``}`

## Java

 `// Java program for the``// above approach``import` `java.util.*;``class` `GFG{` `static` `class` `pair``{``  ``int` `first, second;``  ``public` `pair(``int` `first,``              ``int` `second) ``  ``{``    ``this``.first = first;``    ``this``.second = second;``  ``}   ``}``  ` `// Function to evaluate minimum number``// of operation required to convert``// the matrix to a palindrome matrix``static` `void` `palindromeMatrix(``int` `N, ``int` `M,``                             ``int``[][] arr)``{``  ``// Variable to store number``  ``// of operations required``  ``int` `ans = ``0``;` `  ``// Iterate over the first``  ``// quadrant of the matrix``  ``for` `(``int` `i = ``0``;``           ``i < (N + ``1``) / ``2``; i++)``  ``{``    ``for` `(``int` `j = ``0``;``             ``j < (M + ``1``) / ``2``; j++)``    ``{``      ``// Store positions of all four``      ``// values from four quadrants``      ``HashSet s =``              ``new` `HashSet<>();``      ``s.add(``new` `pair(i, j));``      ``s.add(``new` `pair(i, M - j - ``1``));``      ``s.add(``new` `pair(N - i - ``1``, j));``      ``s.add(``new` `pair(N - i - ``1``,``                     ``M - j - ``1``));` `      ``// Store the values having``      ``// unique indexes``      ``Vector values =``             ``new` `Vector<>();``      ``for` `(pair p : s)``      ``{``        ``values.add(``        ``arr[p.first][p.second]);``      ``}` `      ``// Largest value in the``      ``// values vector``      ``int` `max =``          ``Collections.max(values);` `      ``// Evaluate minimum increments``      ``// required to make all vector``      ``// elements equal``      ``for` `(``int` `k = ``1``;``               ``k < values.size(); k++)``      ``{``        ``ans += max - values.get(k);``      ``}``    ``}``  ``}``  ` `  ``// Print the answer``  ``System.out.print(ans);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``int` `N = ``3``, M = ``3``;``  ``int``[][] arr = {{``1``, ``2``, ``1``},``                 ``{``3``, ``4``, ``1``},``                 ``{``1``, ``2``, ``1``}};` `  ``// Function Call``  ``palindromeMatrix(N, M, arr);``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for the above approach` `# Function to evaluate minimum number``# of operation required to convert``# the matrix to a palindrome matrix``def` `palindromeMatrix(N, M, arr):``    ` `    ``# Variable to store number``    ``# of operations required``    ``ans ``=` `0` `    ``# Iterate over the first``    ``# quadrant of the matrix``    ``for` `i ``in` `range``((N ``+` `1``) ``/``/` `2``):``        ``for` `j ``in` `range``((M ``+` `1``) ``/``/` `2``):``            ` `            ``# Store positions of all four``            ``# values from four quadrants``            ``s ``=` `{}``            ``s[(i, j)] ``=` `1``            ``s[(i, M ``-` `j ``-` `1``)] ``=` `1``            ``s[(N ``-` `i ``-` `1``, j)] ``=` `1``            ``s[(N ``-` `i ``-` `1``, M ``-` `j ``-` `1``)] ``=` `1` `            ``# Store the values having``            ``# unique indexes``            ``values ``=` `[]``            ` `            ``for` `p, q ``in` `s:``                ``values.append(arr[p][q])` `            ``# Largest value in the values vector``            ``maxm ``=` `max``(values)` `            ``# Evaluate minimum increments``            ``# required to make all vector``            ``# elements equal``            ``for` `k ``in` `range``(``len``(values)):``                ``ans ``+``=` `maxm ``-` `values[k]` `    ``# Print the answer``    ``print``(ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``N, M ``=` `3``, ``3``    ` `    ``arr ``=` `[ [ ``1``, ``2``, ``1` `],``            ``[ ``3``, ``4``, ``1` `],``            ``[ ``1``, ``2``, ``1` `] ]` `    ``# Function Call``    ``palindromeMatrix(N, M, arr)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the``// above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `public` `class` `pair``{``  ``public` `int` `first, second;``  ``public` `pair(``int` `first,``              ``int` `second) ``  ``{``    ``this``.first = first;``    ``this``.second = second;``  ``}   ``}``  ` `// Function to evaluate minimum number``// of operation required to convert``// the matrix to a palindrome matrix``static` `void` `palindromeMatrix(``int` `N, ``int` `M,``                             ``int``[,] arr)``{``  ` `  ``// Variable to store number``  ``// of operations required``  ``int` `ans = 0;` `  ``// Iterate over the first``  ``// quadrant of the matrix``  ``for``(``int` `i = 0;``          ``i < (N + 1) / 2; i++)``  ``{``    ``for``(``int` `j = 0;``            ``j < (M + 1) / 2; j++)``    ``{``      ` `      ``// Store positions of all four``      ``// values from four quadrants``      ``HashSet s = ``new` `HashSet();``      ``s.Add(``new` `pair(i, j));``      ``s.Add(``new` `pair(i, M - j - 1));``      ``s.Add(``new` `pair(N - i - 1, j));``      ``s.Add(``new` `pair(N - i - 1,``                     ``M - j - 1));``      ` `      ``// Store the values having``      ``// unique indexes``      ``List<``int``> values = ``new` `List<``int``>();``      ` `      ``foreach` `(pair p ``in` `s)``      ``{``        ``values.Add(arr[p.first, p.second]);``      ``}` `      ``// Largest value in the``      ``// values vector``      ``values.Sort();``      ``int` `max = values[values.Count - 1];``      ` `      ``// Evaluate minimum increments``      ``// required to make all vector``      ``// elements equal``      ``for``(``int` `k = 1;``              ``k < values.Count; k++)``      ``{``        ``ans += max - values[k];``      ``}``    ``}``  ``}``  ` `  ``// Print the answer``  ``Console.Write(ans);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ``int` `N = 3, M = 3;``  ``int``[,] arr = { { 1, 2, 1 },``                 ``{ 3, 4, 1 },``                 ``{ 1, 2, 1 } };` `  ``// Function Call``  ``palindromeMatrix(N, M, arr);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`2`

Time Complexity: O(N * M)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up