 Open in App
Not now

# Minimum steps to convert all paths in matrix from top left to bottom right as palindromic paths

• Last Updated : 16 Jun, 2022

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:
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:
Explanation:
Only one change is required for the every path to be palindromic.
That is => mat = 1
Paths => {1, 2, 1}, {1, 3, 1}

Simple Approach:

The key observation in the problem is that elements at the same distance from the front end or rear end are equal. Therefore, find all the elements at equal distance from (0, 0) and (N-1, M-1) and then make all of them equal in a minimum number of changes. Maintain a count variable to get the total number of changes. Below is the illustration of the approach:

• The distance possible from the top left and bottom right is 0 to N + M – 2.
• Maintain two-pointers one at the top left that is the distance at 0 and another at N + M – 2.
• Iterate over the matrix and for all distance maintain an hash-map of the elements of the matrix at the current distance.
• Update the matrix elements with the minimum number of changes required.
• Finally, increment the left distance by 1 and decrement the right distance by 1.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the``// minimum number of changes required``// such that every path from top left``// to the bottom right``// are palindromic paths` `#include ``using` `namespace` `std;``#define M 3``#define N 3` `// Function to find the minimum number``// of the changes required for the``// every path to be palindromic``int` `minchanges(``int` `mat[N][M])``{``    ``// count variable for``    ``// maintaining total changes.``    ``int` `count = 0;` `    ``// left and right variables for``    ``// keeping distance values``    ``// from cell(0, 0) and``    ``// (N-1, M-1) respectively.``    ``int` `left = 0, right = N + M - 2;` `    ``while` `(left < right) {` `        ``unordered_map<``int``, ``int``> mp;``        ``int` `totalsize = 0;` `        ``// Iterating over the matrix``        ``for` `(``int` `i = 0; i < N; i++) {``            ``for` `(``int` `j = 0; j < M; j++) {``                ``if` `(i + j == left) {``                    ``mp[mat[i][j]]++;``                    ``totalsize++;``                ``}``                ``else` `if` `(i + j == right) {``                    ``mp[mat[i][j]]++;``                    ``totalsize++;``                ``}``            ``}``        ``}` `        ``// Finding minimum number``        ``// of changes required.``        ``unordered_map<``int``, ``int``>::iterator itr = mp.begin();``        ``int` `changes = 0;``        ``for` `(; itr != mp.end(); itr++)``            ``changes = max(changes, itr->second);` `        ``// Minimum no. of changes will``        ``// be the minimum no.``        ``// of different values and``        ``// we will assume to``        ``// make them equals to value``        ``// with maximum frequency element``        ``count += totalsize - changes;` `        ``// Moving ahead with``        ``// greater distance``        ``left++;``        ``right--;``    ``}``    ``return` `count;``}` `// Drive Code``int` `main()``{``    ``int` `mat[][M]``        ``= { { 1, 4, 1 }, { 2, 5, 3 }, { 1, 3, 1 } };` `    ``// Function Call``    ``cout << minchanges(mat);``    ``return` `0;``}`

## Java

 `// Java implementation to find the``// minimum number of changes required``// such that every path from top left``// to the bottom right are palindromic``// paths``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``static` `final` `int` `M = ``3``;``    ``static` `final` `int` `N = ``3``;` `    ``// Function to find the minimum number``    ``// of the changes required for the``    ``// every path to be palindromic``    ``static` `int` `minchanges(``int``[][] mat)``    ``{` `        ``// count variable for``        ``// maintaining total changes.``        ``int` `count = ``0``;` `        ``// left and right variables for``        ``// keeping distance values``        ``// from cell(0, 0) and``        ``// (N-1, M-1) respectively.``        ``int` `left = ``0``, right = N + M - ``2``;` `        ``while` `(left < right) {``            ``Map mp = ``new` `HashMap<>();` `            ``int` `totalsize = ``0``;` `            ``// Iterating over the matrix``            ``for` `(``int` `i = ``0``; i < N; i++) {``                ``for` `(``int` `j = ``0``; j < M; j++) {``                    ``if` `(i + j == left) {``                        ``mp.put(mat[i][j],``                               ``mp.getOrDefault(mat[i][j], ``0``)``                                   ``+ ``1``);``                        ``totalsize++;``                    ``}``                    ``else` `if` `(i + j == right) {``                        ``mp.put(mat[i][j],``                               ``mp.getOrDefault(mat[i][j], ``0``)``                                   ``+ ``1``);``                        ``totalsize++;``                    ``}``                ``}``            ``}` `            ``// Finding minimum number``            ``// of changes required.``            ``int` `changes = ``0``;``            ``for` `(Map.Entry itr :``                 ``mp.entrySet())``                ``changes = Math.max(changes, itr.getValue());` `            ``// Minimum no. of changes will``            ``// be the minimum no.``            ``// of different values and``            ``// we will assume to``            ``// make them equals to value``            ``// with maximum frequency element``            ``count += totalsize - changes;` `            ``// Moving ahead with``            ``// greater distance``            ``left++;``            ``right--;``        ``}``        ``return` `count;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `mat[][]``            ``= { { ``1``, ``4``, ``1` `}, { ``2``, ``5``, ``3` `}, { ``1``, ``3``, ``1` `} };``   ` `        ``// Function Call``        ``System.out.println(minchanges(mat));``    ``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 implementation to find the``# minimum number of changes required``# such that every path from top left``# to the bottom right``# are palindromic paths``M ``=` `3``N ``=` `3` `# Function to find the minimum number``# of the changes required for the``# every path to be palindromic`  `def` `minchanges(mat):``    ` `    ``# count variable for``    ``# maintaining total changes.``    ``count ``=` `0` `    ``# left and right variables for``    ``# keeping distance values``    ``# from cell(0, 0) and``    ``# (N-1, M-1) respectively.``    ``left ``=` `0``    ``right ``=` `N ``+` `M ``-` `2` `    ``while` `(left < right):``        ``mp ``=` `{}``        ``totalsize ``=` `0` `        ``# Iterating over the matrix``        ``for` `i ``in` `range``(N):``            ``for` `j ``in` `range``(M):``                ``if` `(i ``+` `j ``=``=` `left):``                    ``mp[mat[i][j]] ``=``                    ``mp.get(mat[i][j], ``0``) ``+` `1``                    ``totalsize ``+``=` `1``                ``elif` `(i ``+` `j ``=``=` `right):``                    ``mp[mat[i][j]] ``=``                    ``mp.get(mat[i][j], ``0``) ``+` `1``                    ``totalsize ``+``=` `1` `        ``# Finding minimum number``        ``# of changes required.``        ``changes ``=` `0``        ``for` `itr ``in` `mp:``            ``changes ``=` `max``(changes, mp[itr])` `        ``# Minimum no. of changes will``        ``# be the minimum no.``        ``# of different values and``        ``# we will assume to``        ``# make them equals to value``        ``# with maximum frequency element``        ``count ``+``=` `totalsize ``-` `changes` `        ``# Moving ahead with``        ``# greater distance``        ``left ``+``=` `1``        ``right ``-``=` `1``    ``return` `count`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``mat ``=` `[[``1``, ``4``, ``1``],``           ``[``2``, ``5``, ``3``],``           ``[``1``, ``3``, ``1``]]``    ` `    ``# Function Call``    ``print``(minchanges(mat))` `# This code is contributed by Mohit Kumar 29`

## C#

 `// C# implementation to find the``// minimum number of changes required``// such that every path from top left``// to the bottom right are palindromic``// paths``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `class` `GFG {` `    ``static` `int` `M = 3;``    ``static` `int` `N = 3;` `    ``// Function to find the minimum number``    ``// of the changes required for the``    ``// every path to be palindromic``    ``static` `int` `minchanges(``int``[, ] mat)``    ``{` `        ``// count variable for``        ``// maintaining total changes.``        ``int` `count = 0;` `        ``// left and right variables for``        ``// keeping distance values``        ``// from cell(0, 0) and``        ``// (N-1, M-1) respectively.``        ``int` `left = 0, right = N + M - 2;` `        ``while` `(left < right) {``            ``Dictionary<``int``, ``int``> mp``                ``= ``new` `Dictionary<``int``, ``int``>();``            ``int` `totalsize = 0;` `            ``// Iterating over the matrix``            ``for` `(``int` `i = 0; i < N; i++) {``                ``for` `(``int` `j = 0; j < M; j++) {``                    ``if` `(i + j == left) {``                        ``if` `(mp.ContainsKey(mat[i, j])) {``                            ``mp[mat[i, j]]++;``                        ``}``                        ``else` `{``                            ``mp[mat[i, j]] = 1;``                        ``}``                        ``totalsize++;``                    ``}``                    ``else` `if` `(i + j == right) {``                        ``if` `(mp.ContainsKey(mat[i, j])) {``                            ``mp[mat[i, j]]++;``                        ``}``                        ``else` `{``                            ``mp[mat[i, j]] = 1;``                        ``}``                        ``totalsize++;``                    ``}``                ``}``            ``}` `            ``// Finding minimum number``            ``// of changes required.``            ``int` `changes = 0;``            ``foreach``(KeyValuePair<``int``, ``int``> itr ``in` `mp)``            ``{``                ``changes = Math.Max(changes, itr.Value);``            ``}` `            ``// Minimum no. of changes will``            ``// be the minimum no.``            ``// of different values and``            ``// we will assume to``            ``// make them equals to value``            ``// with maximum frequency element``            ``count += totalsize - changes;` `            ``// Moving ahead with``            ``// greater distance``            ``left++;``            ``right--;``        ``}``        ``return` `count;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[, ] mat``            ``= { { 1, 4, 1 }, { 2, 5, 3 }, { 1, 3, 1 } };` `        ``// Function Call``        ``Console.Write(minchanges(mat));``    ``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``

Output:

`2`

Performance Analysis:

• Time Complexity: O(N3)
• Auxiliary Space: O(N)

Efficient Approach:

Algorithm:

• We will use a hashmap to count the frequency of every element which are the same distance from the top and bottom.
• We will use a 2D map for this where the key will be index and the value will be another map which will count frequency
• After counting frequency we will iterate l=0 to r=m+n-1 while l<r and each time we will count the sum and find the max frequency value ≥f
• We will replace (sum-f) elements with the element whose frequency is maximum and store result+=(sum-f)
• Print result

Below is the implementation of the above approach:

## C++

 `// C++ Program to count minimum change``// required to convert all the paths``// pallindromic from top left to``// right bottom cell.``#include ``using` `namespace` `std;` `// Function to find the minimum number``// of the changes required for the``// every path to be palindromic``int` `minchanges(vector >& a)``{``    ``int` `res = 0; ``// use to store final result` `    ``// Row and column``    ``int` `N = a.size(), M = a.size();` `    ``// mp_key -> (i+j) , mp_value -> nw_map``    ``// nw_map_key -> elements_of_matrix``    ``// nw_map_value -> frequency of elements` `    ``// 2-D map``    ``map<``int``, map<``int``, ``int``> > mp;` `    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < M; j++) {``            ` `            ``// calculating position``            ``int` `ind = i + j;``            ` `            ``// increase the frequency of a[i][j]``            ``// at position ind``            ``mp[ind][a[i][j]]++;``        ``}``    ``}``    ` `    ``// Define left and right limit``    ``int` `r = M + N - 2, l = 0;``    ``while` `(l < r) {``        ` `        ``// s-> count total number of elements``        ``// at index l and r``        ``// mx-> store maximum frequency of any element``        ``int` `s = 0, mx = 0;` `        ``// store all elements frequency at index l``        ``for` `(``auto` `x : mp[r]) {``            ``mp[l][x.first] += x.second;``        ``}` `        ``// Count total elements and mx->max_frequency``        ``for` `(``auto` `x : mp[l]) {``            ``s += x.second;``            ``mx = max(x.second, mx);``        ``}` `        ``// We will replace (s-mx) elements with``        ``// the element whose frequency is mx``        ``res += (s - mx);``        ``l++;``        ``r--;``    ``}``  ` `    ``// return res``    ``return` `res;``}` `// Driver Code``int` `main()``{``    ``// Function Call``    ``vector > mat``        ``= { { 1, 4, 1 }, { 2, 5, 3 }, { 1, 3, 1 } };``    ``cout << ``"Total number of changes requires "``         ``<< minchanges(mat) << ``"\n"``;` `    ``// Function Call``    ``vector > mat1``        ``= { { 1, 4 }, { 2, 5 }, { 1, 3 }, { 2, 5 } };``    ``cout << ``"Total number of changes requires "``         ``<< minchanges(mat1) << ``"\n"``;``  ` `    ``return` `0;``}` `// This code is contributed by ajaykr00kj`

Output

```Total number of changes requires 2
Total number of changes requires 3```

Time Complexity: O(m*n)

Space Complexity: O(m*n)

My Personal Notes arrow_drop_up