Minimum increments required to make given matrix palindromic
Last Updated :
22 Jun, 2021
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:
- 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).
- 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.
- Then store the elements present in those unique indexes in vector values and evaluate the maximum in this vector.
- 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++
#include <bits/stdc++.h>
using namespace std;
int palindromeMatrix( int N, int M, vector<vector< int > > arr)
{
int ans = 0;
for ( int i = 0; i < (N + 1) / 2; i++) {
for ( int j = 0; j < (M + 1) / 2; j++) {
set<pair< int , int > > 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 });
vector< int > values;
for (pair< int , int > p : s) {
values.push_back(
arr[p.first][p.second]);
}
int max = *max_element(
values.begin(),
values.end());
for ( int k = 0; k < values.size(); k++) {
ans += max - values[k];
}
}
}
cout << ans;
}
int main()
{
int N = 3, M = 3;
vector<vector< int > > arr
= { { 1, 2, 1 },
{ 3, 4, 1 },
{ 1, 2, 1 } };
palindromeMatrix(N, M, arr);
return 0;
}
|
Java
import java.util.*;
class GFG{
static class pair
{
int first, second;
public pair( int first,
int second)
{
this .first = first;
this .second = second;
}
}
static void palindromeMatrix( int N, int M,
int [][] arr)
{
int ans = 0 ;
for ( int i = 0 ;
i < (N + 1 ) / 2 ; i++)
{
for ( int j = 0 ;
j < (M + 1 ) / 2 ; j++)
{
HashSet<pair> 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 ));
Vector<Integer> values =
new Vector<>();
for (pair p : s)
{
values.add(
arr[p.first][p.second]);
}
int max =
Collections.max(values);
for ( int k = 1 ;
k < values.size(); k++)
{
ans += max - values.get(k);
}
}
}
System.out.print(ans);
}
public static void main(String[] args)
{
int N = 3 , M = 3 ;
int [][] arr = {{ 1 , 2 , 1 },
{ 3 , 4 , 1 },
{ 1 , 2 , 1 }};
palindromeMatrix(N, M, arr);
}
}
|
Python3
def palindromeMatrix(N, M, arr):
ans = 0
for i in range ((N + 1 ) / / 2 ):
for j in range ((M + 1 ) / / 2 ):
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
values = []
for p, q in s:
values.append(arr[p][q])
maxm = max (values)
for k in range ( len (values)):
ans + = maxm - values[k]
print (ans)
if __name__ = = '__main__' :
N, M = 3 , 3
arr = [ [ 1 , 2 , 1 ],
[ 3 , 4 , 1 ],
[ 1 , 2 , 1 ] ]
palindromeMatrix(N, M, arr)
|
C#
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;
}
}
static void palindromeMatrix( int N, int M,
int [,] arr)
{
int ans = 0;
for ( int i = 0;
i < (N + 1) / 2; i++)
{
for ( int j = 0;
j < (M + 1) / 2; j++)
{
HashSet<pair> s = new HashSet<pair>();
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));
List< int > values = new List< int >();
foreach (pair p in s)
{
values.Add(arr[p.first, p.second]);
}
values.Sort();
int max = values[values.Count - 1];
for ( int k = 1;
k < values.Count; k++)
{
ans += max - values[k];
}
}
}
Console.Write(ans);
}
public static void Main(String[] args)
{
int N = 3, M = 3;
int [,] arr = { { 1, 2, 1 },
{ 3, 4, 1 },
{ 1, 2, 1 } };
palindromeMatrix(N, M, arr);
}
}
|
Javascript
<script>
class pair
{
constructor(first, second)
{
this .first = first;
this .second = second;
}
}
function palindromeMatrix(N, M, arr)
{
let ans = 0;
for (let i = 0;
i < Math.floor((N + 1) / 2); i++)
{
for (let j = 0;
j < Math.floor((M + 1) / 2); j++)
{
let s = new Set();
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));
let values = [];
for (let p of s.values())
{
values.push(
arr[p.first][p.second]);
}
values.sort( function (a,b){ return a-b;});
let max =Math.max(...values);
for (let k = 1;
k < values.length; k++)
{
ans += max - values[k];
}
}
}
document.write(ans);
}
let N = 3, M = 3;
let arr=[[1, 2, 1],
[3, 4, 1],
[1, 2, 1]];
palindromeMatrix(N, M, arr);
</script>
|
Time Complexity: O(N * M)
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...