Skip to content
Related Articles

Related Articles

Minimum replacements required to make given Matrix palindromic
  • Last Updated : 31 Dec, 2020

Given a matrix with N rows and M columns, the task is to find the minimum replacements requried to make all rows and columns of a given matrix palindromic.

Examples:

Input: a[][] = {{1, 2, 3}, {4, 5, 3}, {1, 2, 1}}
Output: 2
Explanation: To make the given matrix palindromic, replace a[0][2] by 1 and replace a[1][2] by 4.

Input: a[][] = {{1, 2, 4}, {4, 5, 6}}
Output: 3
Explanation: To make given matrix palindromic, replace a[0][0] by 4, a[1][2] by 4 and a[[0][1] by 5.

Approach: The idea is to select the set of four cells of the matrix as discussed below and proceed accordingly. 



  1. To make each row and each column of the matrix palindromic, traverse over the given matrix and for every cell (i, j) (i = [0, N/2], j = [0, M/2]), select a set of following four cells: 
     
  2. Make the value of all these four cells equal to the most frequent value among four of them. Count the replacements thus required.
  3. After completing the above steps, print the count of replacements performed.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count minimum
// changes to make the matrix
// palindromic
int minchanges(vector<vector<int> > mat)
{
    // Rows in the matrix
    int N = mat.size();
 
    // Columns in the matrix
    int M = mat[0].size();
 
    int i, j, ans = 0, x;
    map<int, int> mp;
 
    // Traverse the given matrix
    for (i = 0; i < N / 2; i++) {
        for (j = 0; j < M / 2; j++) {
 
            // Store the frequency of
            // the four cells
            mp[mat[i][M - 1 - j]]++;
            mp[mat[i][j]]++;
            mp[mat[N - 1 - i][M - 1 - j]]++;
            mp[mat[N - 1 - i][j]]++;
 
            x = 0;
 
            // Iterate over the map
            for (auto it = mp.begin();
                 it != mp.end(); it++) {
                x = max(x, it->second);
            }
 
            // Min changes to do to make all
            ans = ans + 4 - x;
 
            // Four elements equal
            mp.clear();
        }
    }
 
    // Make the middle row palindromic
    if (N % 2 == 1) {
        for (i = 0; i < M / 2; i++) {
            if (mat[N / 2][i]
                != mat[N / 2][M - 1 - i])
                ans++;
        }
    }
 
    if (M % 2 == 1) {
        for (i = 0; i < N / 2; i++) {
 
            // Make the middle column
            // palindromic
            if (mat[i][M / 2]
                != mat[N - 1 - i][M / 2])
                ans++;
        }
    }
 
    // Print minimum changes
    cout << ans;
}
 
// Driver Code
int main()
{
 
    // Given matrix
    vector<vector<int> > mat{ { 1, 2, 3 },
                              { 4, 5, 3 },
                              { 1, 2, 1 } };
 
    // Function Call
    minchanges(mat);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
class GFG{
 
// Function to count minimum
// changes to make the matrix
// palindromic
static void minchanges(int [][]mat)
{
   
    // Rows in the matrix
    int N = mat.length;
 
    // Columns in the matrix
    int M = mat[0].length;
 
    int i, j, ans = 0, x;
    HashMap<Integer,Integer> mp = new HashMap<Integer,Integer>();
 
    // Traverse the given matrix
    for (i = 0; i < N / 2; i++)
    {
        for (j = 0; j < M / 2; j++)
        {
 
            // Store the frequency of
            // the four cells           
            if(mp.containsKey(mat[i][M - 1 - j]))
            {
                mp.put(mat[i][M - 1 - j],
                       mp.get(mat[i][M - 1 - j]) + 1);
            }
            else
            {
                mp.put(mat[i][M - 1 - j], 1);
            }
            if(mp.containsKey(mat[i][j]))
            {
                mp.put(mat[i][j], mp.get(mat[i][j]) + 1);
            }
            else
            {
                mp.put(mat[i][j], 1);
            }
             
            if(mp.containsKey(mat[N - 1 - i][M - 1 - j]))
            {
                mp.put(mat[N - 1 - i][M - 1 - j],
                       mp.get(mat[N - 1 - i][M - 1 - j]) + 1);
            }
            else
            {
                mp.put(mat[N - 1 - i][M - 1 - j], 1);
            }
            if(mp.containsKey(mat[N - 1 - i][j]))
            {
                mp.put(mat[N - 1 - i][j],
                       mp.get(mat[N - 1 - i][j])+1);
            }
            else
            {
                mp.put(mat[N - 1 - i][j], 1);
            }
            x = 0;
 
            // Iterate over the map
            for (Map.Entry<Integer,Integer> it : mp.entrySet())
            {
                x = Math.max(x, it.getValue());
            }
 
            // Min changes to do to make all
            ans = ans + 4 - x;
 
            // Four elements equal
            mp.clear();
        }
    }
 
    // Make the middle row palindromic
    if (N % 2 == 1)
    {
        for (i = 0; i < M / 2; i++)
        {
            if (mat[N / 2][i]
                != mat[N / 2][M - 1 - i])
                ans++;
        }
    }
 
    if (M % 2 == 1)
    {
        for (i = 0; i < N / 2; i++)
        {
 
            // Make the middle column
            // palindromic
            if (mat[i][M / 2]
                != mat[N - 1 - i][M / 2])
                ans++;
        }
    }
 
    // Print minimum changes
    System.out.print(ans);
}
 
// Driver Code
public static void main(String[] args)
{
 
    // Given matrix
    int [][]mat = { { 1, 2, 3 },
                              { 4, 5, 3 },
                              { 1, 2, 1 } };
 
    // Function Call
    minchanges(mat);
}
}
 
// This code is contributed by shikhasingrajput

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program for the above approach
  
# Function to count minimum
# changes to make the matrix
# palindromic
def minchanges(mat) :
     
    # Rows in the matrix
    N = len(mat)
  
    # Columns in the matrix
    M = len(mat[0])
  
    ans = 0
    mp = {}
  
    # Traverse the given matrix
    for i in range(N//2):
        for j in range(M//2):
  
            # Store the frequency of
            # the four cells
            mp[mat[i][M - 1 - j]] = mp.get(mat[i][M - 1 - j], 0) + 1
            mp[mat[i][j]] = mp.get(mat[i][j], 0) + 1
            mp[mat[N - 1 - i][M - 1 - j]] = mp.get(mat[N - 1 - i][M - 1 - j], 0) + 1
            mp[mat[N - 1 - i][j]] = mp.get(mat[N - 1 - i][j], 0) + 1
  
            x = 0
  
            # Iterate over the map
            for it in mp:
                x = max(x, mp[it])
             
  
            # Min changes to do to make all
            ans = ans + 4 - x
  
            # Four elements equal
            mp.clear()
          
    # Make the middle row palindromic
    if (N % 2 == 1) :
        for i in range(M // 2):
            if (mat[N // 2][i]
                != mat[N // 2][M - 1 - i]) :
                ans += 1
         
    if (M % 2 == 1) :
        for i in range(N // 2):
  
            # Make the middle column
            # palindromic
            if (mat[i][M // 2]
                != mat[N - 1 - i][M // 2]):
                ans += 1
         
    # Prminimum changes
    print(ans)
  
# Driver Code
 
# Given matrix
mat = [[ 1, 2, 3 ],
        [ 4, 5, 3 ],
        [1, 2, 1 ]]
  
# Function Call
minchanges(mat)
 
# This code is contributed by susmitakundugoaldanga

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
 
  // Function to count minimum
  // changes to make the matrix
  // palindromic
  static void minchanges(int [,]mat)
  {
 
    // Rows in the matrix
    int N = mat.GetLength(0);
 
    // Columns in the matrix
    int M = mat.GetLength(1);
 
    int i, j, ans = 0, x;
    Dictionary<int,int> mp = new Dictionary<int,int>();
 
    // Traverse the given matrix
    for (i = 0; i < N / 2; i++)
    {
      for (j = 0; j < M / 2; j++)
      {
 
        // Store the frequency of
        // the four cells           
        if(mp.ContainsKey(mat[i,M - 1 - j]))
        {
          mp[mat[i,M - 1 - j]]=
            mp[mat[i,M - 1 - j]] + 1;
        }
        else
        {
          mp.Add(mat[i,M - 1 - j], 1);
        }
        if(mp.ContainsKey(mat[i,j]))
        {
          mp[mat[i,j]] = mp[mat[i,j]] + 1;
        }
        else
        {
          mp.Add(mat[i,j], 1);
        }
 
        if(mp.ContainsKey(mat[N - 1 - i,M - 1 - j]))
        {
          mp[mat[N - 1 - i,M - 1 - j]]=
            mp[mat[N - 1 - i,M - 1 - j]] + 1;
        }
        else
        {
          mp.Add(mat[N - 1 - i,M - 1 - j], 1);
        }
        if(mp.ContainsKey(mat[N - 1 - i,j]))
        {
          mp[mat[N - 1 - i,j]] =
            mp[mat[N - 1 - i,j]]+1;
        }
        else
        {
          mp.Add(mat[N - 1 - i,j], 1);
        }
        x = 0;
 
        // Iterate over the map
        foreach (KeyValuePair<int,int> it in mp)
        {
          x = Math.Max(x, it.Value);
        }
 
        // Min changes to do to make all
        ans = ans + 4 - x;
 
        // Four elements equal
        mp.Clear();
      }
    }
 
    // Make the middle row palindromic
    if (N % 2 == 1)
    {
      for (i = 0; i < M / 2; i++)
      {
        if (mat[N / 2,i]
            != mat[N / 2,M - 1 - i])
          ans++;
      }
    }
 
    if (M % 2 == 1)
    {
      for (i = 0; i < N / 2; i++)
      {
 
        // Make the middle column
        // palindromic
        if (mat[i,M / 2]
            != mat[N - 1 - i,M / 2])
          ans++;
      }
    }
 
    // Print minimum changes
    Console.Write(ans);
  }
 
  // Driver Code
  public static void Main(String[] args)
  {
 
    // Given matrix
    int [,]mat = { { 1, 2, 3 },
                  { 4, 5, 3 },
                  { 1, 2, 1 } };
 
    // Function Call
    minchanges(mat);
  }
}
 
// This code contributed by shikhasingrajput

chevron_right


 
 

Output: 

2

 

 

Time Complexity: O(N × M)
Auxiliary Space: O(1) 

 

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :