Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Last Updated : 03 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:

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}

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 <bits/stdc++.h>
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 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<Integer, Integer> 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<Integer, Integer> itr :
                 mp.entrySet())
                changes = Math.max(changes, itr.getValue());
 
            // Minimum no. of changes will
            // be the 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 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 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



<script>
 
// Javascript implementation to find the
// minimum number of changes required
// such that every path from top left
// to the bottom right
// are palindromic paths
var M = 3
var N = 3;
 
// Function to find the minimum number
// of the changes required for the
// every path to be palindromic
function minchanges(mat)
{
    // count variable for
    // maintaining total changes.
    var count = 0;
 
    // left and right variables for
    // keeping distance values
    // from cell(0, 0) and
    // (N-1, M-1) respectively.
    var left = 0, right = N + M - 2;
 
    while (left < right) {
 
        var mp = new Map();
        var totalsize = 0;
 
        // Iterating over the matrix
        for (var i = 0; i < N; i++) {
            for (var j = 0; j < M; j++) {
                if (i + j == left || i + j == right) {
                    if(mp.has(mat[i][j]))
                        mp.set(mat[i][j], mp.get(mat[i][j])+1)
                    else
                        mp.set(mat[i][j], 1)
                    totalsize++;
                }
            }
        }
 
        var changes = 0;
        // Finding minimum number
        // of changes required.
        mp.forEach((value, key) => {
            changes = Math.max(changes, value);
        });
         
 
        // Minimum no. of changes will
        // be the 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
var mat
    = [ [ 1, 4, 1 ], [ 2, 5, 3 ], [ 1, 3, 1 ] ];
// Function Call
document.write( minchanges(mat));
 
// This code is contributed by importantly.
</script>
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 <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum number
// of the changes required for the
// every path to be palindromic
int minchanges(vector<vector<int> >& a)
{
    int res = 0; // use to store final result
 
    // Row and column
    int N = a.size(), M = a[0].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<vector<int> > mat
        = { { 1, 4, 1 }, { 2, 5, 3 }, { 1, 3, 1 } };
    cout << "Total number of changes requires "
         << minchanges(mat) << "\n";
 
    // Function Call
    vector<vector<int> > 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
Previous
Minimum steps to convert all paths in matrix from top left to bottom right as palindromic paths | Set 2
Next

N Queen Problem | Backtracking-3
Recommended Articles
Page :
Minimum steps to convert all paths in matrix from top left to bottom right as palindromic paths | Set 2
29, Jul 20
Minimum steps to convert all top left to bottom right paths in Matrix as palindrome | Set 2
15, Jul 20
Print all palindromic paths from top left to bottom right in a matrix
20, Sep 17
Count of possible paths from top left to bottom right of a M x N matrix by moving right, down or diagonally
30, Dec 21
Minimize flips required to make all shortest paths from top-left to bottom-right of a binary matrix equal to S
04, Sep 20
Count all possible paths from top left to bottom right of a Matrix without crossing the diagonal
07, Sep 20
Print all possible paths from top left to bottom right of a mXn matrix
22, Dec 13
Print all paths from top left to bottom right in a matrix with four moves allowed
25, Dec 18
Count all possible paths from top left to bottom right of a mXn matrix
31, Dec 13
Minimize count of unique paths from top left to bottom right of a Matrix by placing K 1s
02, Sep 20
Minimum cost to reach from the top-left to the bottom-right corner of a matrix
06, Jan 20
Minimum number of flips required such that a Binary Matrix doesn't contain any path from the top left to the bottom right consisting only of 0s
29, Jun 21
Lexicographically largest prime path from top-left to bottom-right in a matrix
16, Oct 18
Maximum XOR of a path from top-left to bottom-right cell of given Matrix
25, Oct 20
Print matrix elements from top-left to bottom right in diagonally upward manner
23, Nov 20
Maximum points from top left of matrix to bottom right and return back
01, Oct 17
Maximum sum path in a matrix from top-left to bottom-right
10, Sep 20
Maximize trailing zeros in product from top left to bottom right of given Matrix
27, Oct 20
Maximum non-negative product of a path from top left to bottom right of given Matrix
23, Nov 20
Maximum path sum from top left to bottom right of a matrix passing through one of the given cells
15, Jun 21
Maximum points by traversing from top left of Matrix to bottom right by two persons
09, Aug 21
Shortest path in a Matrix from top-left to bottom right-corner with neighbors exceeding at most K
24, Nov 21
Minimize cost to reach bottom right from top left corner of Matrix with given separate cost for each move
11, Jan 22
Print a matrix in alternate manner (left to right then right to left)
26, Feb 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
pradyumanagarwal
@pradyumanagarwal
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!