# Minimum steps to convert all top left to bottom right paths in Matrix as palindrome | Set 2

• Last Updated : 14 Jun, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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

1. 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].
2. 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.
3. 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.
4. 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++

 `// C++ program for the above approach``#include ``using` `namespace` `std;``#define N 7` `// Function for counting minimum``// number of changes``int` `countChanges(``int` `matrix[][N],``                 ``int` `n, ``int` `m)``{``    ``// Distance of elements from (0, 0)``    ``// will is i range [0, n + m - 2]``    ``int` `dist = n + m - 1;` `    ``// Store frequencies of [0, 9]``    ``// at distance i``    ``int` `freq[dist];` `    ``// Initialize frequencies as 0``    ``for` `(``int` `i = 0; i < dist; i++) {``        ``for` `(``int` `j = 0; j < 10; j++)``            ``freq[i][j] = 0;``    ``}` `    ``// Count frequencies of [0, 9]``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = 0; j < m; j++) {` `            ``// Increment frequency of``            ``// value matrix[i][j]``            ``// at distance i+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;` `        ``// Find value with max frequency``        ``// and count total cells at distance i``        ``// from front end and rear end``        ``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]);``        ``}` `        ``// Change all values to the``        ``// value with max frequency``        ``min_changes_sum += (total_values``                            ``- maximum);``    ``}` `    ``// Return the answer``    ``return` `min_changes_sum;``}` `// Driver Code``int` `main()``{``    ``// Given Matrix``    ``int` `mat[][N] = { { 1, 2 }, { 3, 5 } };` `    ``// Function Call``    ``cout << countChanges(mat, 2, 2);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ` `static` `final` `int` `N = ``7``;` `// Function for counting minimum``// number of changes``static` `int` `countChanges(``int` `matrix[][],``                        ``int` `n, ``int` `m)``{``    ` `    ``// Distance of elements from (0, 0)``    ``// will is i range [0, n + m - 2]``    ``int` `dist = n + m - ``1``;` `    ``// Store frequencies of [0, 9]``    ``// at distance i``    ``int` `[][]freq = ``new` `int``[dist][``10``];` `    ``// Initialize frequencies as 0``    ``for``(``int` `i = ``0``; i < dist; i++)``    ``{``        ``for``(``int` `j = ``0``; j < ``10``; j++)``            ``freq[i][j] = ``0``;``    ``}` `    ``// Count frequencies of [0, 9]``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``for``(``int` `j = ``0``; j < m; j++)``        ``{``            ` `            ``// Increment frequency of``            ``// value matrix[i][j]``            ``// at distance i+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``;` `        ``// Find value with max frequency``        ``// and count total cells at distance i``        ``// from front end and rear end``        ``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]);``        ``}``        ` `        ``// Change all values to the``        ``// value with max frequency``        ``min_changes_sum += (total_values -``                            ``maximum);``    ``}` `    ``// Return the answer``    ``return` `min_changes_sum;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given matrix``    ``int` `mat[][] = { { ``1``, ``2` `}, { ``3``, ``5` `} };` `    ``// Function call``    ``System.out.print(countChanges(mat, ``2``, ``2``));``}``}` `// This code is contributed by Rohit_ranjan`

## Python3

 `# Python3 program for the above approach` `# Function for counting minimum``# number of changes``def` `countChanges(matrix, n, m):` `    ``# Distance of elements from (0, 0)``    ``# will is i range [0, n + m - 2]``    ``dist ``=` `n ``+` `m ``-` `1` `    ``# Store frequencies of [0, 9]``    ``# at distance i``    ``# Initialize all with zero``    ``freq ``=` `[[``0``] ``*` `10` `for` `i ``in` `range``(dist)]` `    ``# Count frequencies of [0, 9]``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(m):` `            ``# Increment frequency of``            ``# value matrix[i][j]``            ``# at distance i+j``            ``freq[i ``+` `j][matrix[i][j]] ``+``=` `1` `    ``min_changes_sum ``=` `0` `    ``for` `i ``in` `range``(dist ``/``/` `2``):``        ``maximum ``=` `0``        ``total_values ``=` `0` `        ``# Find value with max frequency``        ``# and count total cells at distance i``        ``# from front end and rear end        ``        ``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])` `        ``# Change all values to the value``        ``# with max frequency``        ``min_changes_sum ``+``=` `(total_values ``-``                            ``maximum)``                            ` `    ``# Return the answer``    ``return` `min_changes_sum` `# Driver code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Given matrix``    ``mat ``=` `[ [ ``1``, ``2` `], [ ``3``, ``5` `] ]` `    ``# Function call``    ``print``(countChanges(mat, ``2``, ``2``))` `# This code is contributed by himanshu77`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `//static readonly int N = 7;` `// Function for counting minimum``// number of changes``static` `int` `countChanges(``int` `[,]matrix,``                        ``int` `n, ``int` `m)``{``    ` `    ``// Distance of elements from (0, 0)``    ``// will is i range [0, n + m - 2]``    ``int` `dist = n + m - 1;` `    ``// Store frequencies of [0, 9]``    ``// at distance i``    ``int` `[,]freq = ``new` `int``[dist, 10];` `    ``// Initialize frequencies as 0``    ``for``(``int` `i = 0; i < dist; i++)``    ``{``        ``for``(``int` `j = 0; j < 10; j++)``            ``freq[i, j] = 0;``    ``}` `    ``// Count frequencies of [0, 9]``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``for``(``int` `j = 0; j < m; j++)``        ``{``            ` `            ``// Increment frequency of``            ``// value matrix[i,j]``            ``// at distance i+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;` `        ``// Find value with max frequency``        ``// and count total cells at distance i``        ``// from front end and rear end``        ``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]);``        ``}``        ` `        ``// Change all values to the``        ``// value with max frequency``        ``min_changes_sum += (total_values -``                            ``maximum);``    ``}` `    ``// Return the answer``    ``return` `min_changes_sum;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given matrix``    ``int` `[,]mat = { { 1, 2 }, { 3, 5 } };` `    ``// Function call``    ``Console.Write(countChanges(mat, 2, 2));``}``}` `// This code is contributed by Rohit_ranjan`

## Javascript

 ``
Output:
`1`

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

My Personal Notes arrow_drop_up