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

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:

  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][10].
  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: 



filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <bits/stdc++.h>
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][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 = 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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 
chevron_right

Output: 
1

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

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.




Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : himanshu77, Rohit_ranjan

Article Tags :