Minimum steps to convert all top left to bottom right paths in Matrix as palindrome | Set 2
Last Updated :
24 Mar, 2023
Given a matrix mat[][] with N rows and M columns. The task is to find the minimum number of changes required in the matrix such that every path from top left to bottom right is a palindromic path. In a path only right and bottom movements are allowed from one cell to another cell.
Examples:
Input: mat[][] = {{1, 2}, {3, 1}}
Output: 0
Explanation:
Every path in the matrix from top left to bottom right is palindromic.
Paths => {1, 2, 1}, {1, 3, 1}
Input: mat[][] = {{1, 2}, {3, 5}}
Output: 1
Explanation:
Only one change is required for the every path to be palindromic.
That is => mat[1][1] = 1
Paths => {1, 2, 1}, {1, 3, 1}
Naive Approach: For the naive approach please refer to this post.
Efficient Approach: The idea is to discard the use of an extra space that is the use of HashMap. Follow the steps given below:
- Distance possible from top left and bottom right are in the range 0 to N + M – 2. Hence create a 2D array of dimensions [N + M – 1][10].
- Store frequency of distances in an array while considering Row number (in range 0 to N + M – 2) as distance and column number (0 to 9) as an element in the given matrix.
- For the number of changes to be minimum, change each cell at distance X with a value that has the highest frequency among all values at distance X.
- The minimum number of steps required is the sum of the difference of total values of frequency and the maximum value of frequency for each distance.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
#define N 7
int countChanges( int matrix[][N],
int n, int m)
{
int dist = n + m - 1;
int freq[dist][10];
for ( int i = 0; i < dist; i++) {
for ( int j = 0; j < 10; j++)
freq[i][j] = 0;
}
for ( int i = 0; i < n; i++) {
for ( int j = 0; j < m; j++) {
freq[i + j][(matrix[i][j])]++;
}
}
int min_changes_sum = 0;
for ( int i = 0; i < dist / 2; i++) {
int maximum = 0;
int total_values = 0;
for ( int j = 0; j < 10; j++) {
maximum = max(maximum, freq[i][j]
+ freq[n + m - 2 - i][j]);
total_values += (freq[i][j]
+ freq[n + m - 2 - i][j]);
}
min_changes_sum += (total_values
- maximum);
}
return min_changes_sum;
}
int main()
{
int mat[][N] = { { 1, 2 }, { 3, 5 } };
cout << countChanges(mat, 2, 2);
return 0;
}
|
Java
import java.util.*;
class GFG{
static final int N = 7 ;
static int countChanges( int matrix[][],
int n, int m)
{
int dist = n + m - 1 ;
int [][]freq = new int [dist][ 10 ];
for ( int i = 0 ; i < dist; i++)
{
for ( int j = 0 ; j < 10 ; j++)
freq[i][j] = 0 ;
}
for ( int i = 0 ; i < n; i++)
{
for ( int j = 0 ; j < m; j++)
{
freq[i + j][(matrix[i][j])]++;
}
}
int min_changes_sum = 0 ;
for ( int i = 0 ; i < dist / 2 ; i++)
{
int maximum = 0 ;
int total_values = 0 ;
for ( int j = 0 ; j < 10 ; j++)
{
maximum = Math.max(maximum, freq[i][j] +
freq[n + m - 2 - i][j]);
total_values += (freq[i][j] +
freq[n + m - 2 - i][j]);
}
min_changes_sum += (total_values -
maximum);
}
return min_changes_sum;
}
public static void main(String[] args)
{
int mat[][] = { { 1 , 2 }, { 3 , 5 } };
System.out.print(countChanges(mat, 2 , 2 ));
}
}
|
Python3
def countChanges(matrix, n, m):
dist = n + m - 1
freq = [[ 0 ] * 10 for i in range (dist)]
for i in range (n):
for j in range (m):
freq[i + j][(matrix[i][j])] + = 1
min_changes_sum = 0
for i in range (dist / / 2 ):
maximum = 0
total_values = 0
for j in range ( 10 ):
maximum = max (maximum, freq[i][j] +
freq[n + m - 2 - i][j])
total_values + = (freq[i][j] +
freq[n + m - 2 - i][j])
min_changes_sum + = (total_values -
maximum)
return min_changes_sum
if __name__ = = '__main__' :
mat = [ [ 1 , 2 ], [ 3 , 5 ] ]
print (countChanges(mat, 2 , 2 ))
|
C#
using System;
class GFG{
static int countChanges( int [,]matrix,
int n, int m)
{
int dist = n + m - 1;
int [,]freq = new int [dist, 10];
for ( int i = 0; i < dist; i++)
{
for ( int j = 0; j < 10; j++)
freq[i, j] = 0;
}
for ( int i = 0; i < n; i++)
{
for ( int j = 0; j < m; j++)
{
freq[i + j, matrix[i, j]]++;
}
}
int min_changes_sum = 0;
for ( int i = 0; i < dist / 2; i++)
{
int maximum = 0;
int total_values = 0;
for ( int j = 0; j < 10; j++)
{
maximum = Math.Max(maximum, freq[i, j] +
freq[n + m - 2 - i, j]);
total_values += (freq[i, j] +
freq[n + m - 2 - i, j]);
}
min_changes_sum += (total_values -
maximum);
}
return min_changes_sum;
}
public static void Main(String[] args)
{
int [,]mat = { { 1, 2 }, { 3, 5 } };
Console.Write(countChanges(mat, 2, 2));
}
}
|
Javascript
<script>
var N = 7;
function countChanges(matrix, n, m)
{
var dist = n + m - 1;
var freq = Array.from(Array(dist), ()=>Array(10));
for ( var i = 0; i < dist; i++) {
for ( var j = 0; j < 10; j++)
freq[i][j] = 0;
}
for ( var i = 0; i < n; i++) {
for ( var j = 0; j < m; j++) {
freq[i + j][(matrix[i][j])]++;
}
}
var min_changes_sum = 0;
for ( var i = 0; i < parseInt(dist / 2); i++) {
var maximum = 0;
var total_values = 0;
for ( var j = 0; j < 10; j++) {
maximum = Math.max(maximum, freq[i][j]
+ freq[n + m - 2 - i][j]);
total_values += (freq[i][j]
+ freq[n + m - 2 - i][j]);
}
min_changes_sum += (total_values
- maximum);
}
return min_changes_sum;
}
var mat = [[1, 2], [3, 5 ]];
document.write( countChanges(mat, 2, 2));
</script>
|
Time Complexity: O(N*M)
Auxiliary Space: O(N*M)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...