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

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

using System;
using System.Collections.Generic;

class Program
{
    // Function to find the minimum number
    // of the changes required for the
    // every path to be palindromic
    static int MinChanges(List<List<int>> a)
    {
        int res = 0; // use to store final result

        // Row and column
        int N = a.Count, M = a[0].Count;

        // mp_key -> (i+j) , mp_value -> nw_map
        // nw_map_key -> elements_of_matrix
        // nw_map_value -> frequency of elements

        // 2-D dictionary
        Dictionary<int, Dictionary<int, int>> mp = new Dictionary<int, 
                        Dictionary<int, int>>();

        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
                if (!mp.ContainsKey(ind))
                    mp[ind] = new Dictionary<int, int>();
                if (!mp[ind].ContainsKey(a[i][j]))
                    mp[ind][a[i][j]] = 0;
                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
            if (!mp.ContainsKey(r))
                mp[r] = new Dictionary<int, int>();
            foreach (var x in mp[r])
            {
                if (!mp.ContainsKey(l))
                    mp[l] = new Dictionary<int, int>();
                if (!mp[l].ContainsKey(x.Key))
                    mp[l][x.Key] = 0;
                mp[l][x.Key] += x.Value;
            }

            // Count total elements and mx->max_frequency
            foreach (var x in mp[l])
            {
                s += x.Value;
                mx = Math.Max(x.Value, 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
    static void Main(string[] args)
    {
        // Function Call
        List<List<int>> mat = new List<List<int>>()
        {
            new List<int>() { 1, 4, 1 },
            new List<int>() { 2, 5, 3 },
            new List<int>() { 1, 3, 1 }
        };
        Console.WriteLine("Total number of changes required: " + MinChanges(mat));

        // Function Call
        List<List<int>> mat1 = new List<List<int>>()
        {
            new List<int>() { 1, 4 },
            new List<int>() { 2, 5 },
            new List<int>() { 1, 3 },
            new List<int>() { 2, 5 }
        };
        Console.WriteLine("Total number of changes required: " + MinChanges(mat1));
    }
}