Skip to content
Related Articles
Maximize sum of diagonal of a matrix by rotating all rows or all columns
• Difficulty Level : Easy
• Last Updated : 23 Apr, 2021

Given a square matrix, mat[][] of dimensions N * N, the task is find the maximum sum of diagonal elements possible from the given matrix by rotating either all the rows or all the columns of the matrix by a positive integer.

Examples:

Input: mat[][] = { { 1, 1, 2 }, { 2, 1, 2 }, { 1, 2, 2 } }
Output:
Explanation:
Rotating all the columns of matrix by 1 modifies mat[][] to { {2, 1, 2}, {1, 2, 2}, {1, 1, 2} }.
Therefore, the sum of diagonal elements of the matrix = 2 + 2 + 2 = 6 which is the maximum possible.

Input: A[][] = { { -1, 2 }, { -1, 3 } }
Output: 2

Approach: The idea is to rotate all the rows and columns of the matrix in all possible ways and calculate the maximum sum obtained. Follow the steps to solve the problem:

• Initialize a variable, say maxDiagonalSum to store the maximum possible sum of diagonal elements the matrix by rotating all the rows or columns of the matrix.
• Rotate all the rows of the matrix by a positive integer in the range [0, N – 1] and update the value of maxDiagonalSum.
• Rotate all the columns of the matrix by a positive integer in the range [0, N – 1] and update the value of maxDiagonalSum.
• Finally, print the value of maxDiagonalSum.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;``#define N 3`  `// Function to find maximum sum of diagonal elements``// of matrix by rotating either rows or columns``int` `findMaximumDiagonalSumOMatrixf(``int` `A[][N])``{``    ` `    ` `    ``// Stores maximum diagonal sum of elements``    ``// of matrix by rotating rows or columns``    ``int` `maxDiagonalSum = INT_MIN;``    `  `    ``// Rotate all the columns by an integer``    ``// in the range [0, N - 1]``    ``for` `(``int` `i = 0; i < N; i++) {``        `  `        ``// Stores sum of diagonal elements``        ``// of the matrix``        ``int` `curr = 0;``        `  `        ``// Calculate sum of diagonal``        ``// elements of the matrix``        ``for` `(``int` `j = 0; j < N; j++) {``            `  `            ``// Update curr``            ``curr += A[j][(i + j) % N];``        ``}``        ` `        ` `        ``// Update maxDiagonalSum``        ``maxDiagonalSum = max(maxDiagonalSum,``                                      ``curr);``    ``}`  `    ``// Rotate all the rows by an integer``    ``// in the range [0, N - 1]``    ``for` `(``int` `i = 0; i < N; i++) {``        `  `        ``// Stores sum of diagonal elements``        ``// of the matrix``        ``int` `curr = 0;``        `  `        ``// Calculate sum of diagonal``        ``// elements of the matrix``        ``for` `(``int` `j = 0; j < N; j++) {``            `  `            ``// Update curr``            ``curr += A[(i + j) % N][j];``        ``}``        ` `        ` `        ``// Update maxDiagonalSum``        ``maxDiagonalSum = max(maxDiagonalSum,``                                      ``curr);``    ``}` `      ` `    ``return` `maxDiagonalSum;``}`  `// Driver code``int` `main()``{``    ` `    ``int` `mat[N][N] = { { 1, 1, 2 },``                    ``{ 2, 1, 2 },``                    ``{ 1, 2, 2 } };``    ` `    ``cout<< findMaximumDiagonalSumOMatrixf(mat);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{` `static` `int` `N = ``3``;`` ` `// Function to find maximum sum of``// diagonal elements of matrix by``// rotating either rows or columns``static` `int` `findMaximumDiagonalSumOMatrixf(``int` `A[][])``{``    ` `    ``// Stores maximum diagonal sum of elements``    ``// of matrix by rotating rows or columns``    ``int` `maxDiagonalSum = Integer.MIN_VALUE;``    ` `    ``// Rotate all the columns by an integer``    ``// in the range [0, N - 1]``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// Stores sum of diagonal elements``        ``// of the matrix``        ``int` `curr = ``0``;``        ` `        ``// Calculate sum of diagonal``        ``// elements of the matrix``        ``for``(``int` `j = ``0``; j < N; j++)``        ``{``            ` `            ``// Update curr``            ``curr += A[j][(i + j) % N];``        ``}``         ` `        ``// Update maxDiagonalSum``        ``maxDiagonalSum = Math.max(maxDiagonalSum,``                                  ``curr);``    ``}``    ` `    ``// Rotate all the rows by an integer``    ``// in the range [0, N - 1]``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// Stores sum of diagonal elements``        ``// of the matrix``        ``int` `curr = ``0``;``        ` `        ``// Calculate sum of diagonal``        ``// elements of the matrix``        ``for``(``int` `j = ``0``; j < N; j++)``        ``{``            ` `            ``// Update curr``            ``curr += A[(i + j) % N][j];``        ``}``        ` `        ``// Update maxDiagonalSum``        ``maxDiagonalSum = Math.max(maxDiagonalSum,``                                  ``curr);``    ``}``    ``return` `maxDiagonalSum;``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int``[][] mat = { { ``1``, ``1``, ``2` `},``                    ``{ ``2``, ``1``, ``2` `},``                    ``{ ``1``, ``2``, ``2` `} };``     ` `    ``System.out.println(``        ``findMaximumDiagonalSumOMatrixf(mat));``}``}` `// This code is contributed by susmitakundugoaldanga`

## Python3

 `# Python3 program to implement``# the above approach``import` `sys` `N ``=` `3` `# Function to find maximum sum of diagonal``# elements of matrix by rotating either``# rows or columns``def` `findMaximumDiagonalSumOMatrixf(A):``    ` `    ``# Stores maximum diagonal sum of elements``    ``# of matrix by rotating rows or columns``    ``maxDiagonalSum ``=` `-``sys.maxsize ``-` `1` `    ``# Rotate all the columns by an integer``    ``# in the range [0, N - 1]``    ``for` `i ``in` `range``(N):     ` `        ``# Stores sum of diagonal elements``        ``# of the matrix``        ``curr ``=` `0``        ` `        ``# Calculate sum of diagonal``        ``# elements of the matrix``        ``for` `j ``in` `range``(N):``            ` `            ``# Update curr``            ``curr ``+``=` `A[j][(i ``+` `j) ``%` `N]``       ` `        ``# Update maxDiagonalSum``        ``maxDiagonalSum ``=` `max``(maxDiagonalSum,``                             ``curr)``                             ` `    ``# Rotate all the rows by an integer``    ``# in the range [0, N - 1]``    ``for` `i ``in` `range``(N):``        ` `        ``# Stores sum of diagonal elements``        ``# of the matrix``        ``curr ``=` `0``        ` `        ``# Calculate sum of diagonal``        ``# elements of the matrix``        ``for` `j ``in` `range``(N):         ``            ` `            ``# Update curr``            ``curr ``+``=` `A[(i ``+` `j) ``%` `N][j]``        ` `        ``# Update maxDiagonalSum``        ``maxDiagonalSum ``=` `max``(maxDiagonalSum,``                             ``curr)``                             ` `    ``return` `maxDiagonalSum` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``mat ``=` `[ [ ``1``, ``1``, ``2` `],``            ``[ ``2``, ``1``, ``2` `],``            ``[ ``1``, ``2``, ``2` `] ]``    ` `    ``print``(findMaximumDiagonalSumOMatrixf(mat))``    ` `# This code is contributed by chitranayal`

## C#

 `// C# program to implement``// the above approach ``using` `System;``  ` `class` `GFG{``  ` `static` `int` `N = 3;``  ` `// Function to find maximum sum of``// diagonal elements of matrix by``// rotating either rows or columns``static` `int` `findMaximumDiagonalSumOMatrixf(``int``[,] A)``{``    ` `    ``// Stores maximum diagonal sum of elements``    ``// of matrix by rotating rows or columns``    ``int` `maxDiagonalSum = Int32.MinValue;``    ` `    ``// Rotate all the columns by an integer``    ``// in the range [0, N - 1]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Stores sum of diagonal elements``        ``// of the matrix``        ``int` `curr = 0;``         ` `        ``// Calculate sum of diagonal``        ``// elements of the matrix``        ``for``(``int` `j = 0; j < N; j++)``        ``{``            ` `            ``// Update curr``            ``curr += A[j, (i + j) % N];``        ``}``        ` `        ``// Update maxDiagonalSum``        ``maxDiagonalSum = Math.Max(maxDiagonalSum,``                                  ``curr);``    ``}``     ` `    ``// Rotate all the rows by an integer``    ``// in the range [0, N - 1]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Stores sum of diagonal elements``        ``// of the matrix``        ``int` `curr = 0;``         ` `        ``// Calculate sum of diagonal``        ``// elements of the matrix``        ``for``(``int` `j = 0; j < N; j++)``        ``{``            ` `            ``// Update curr``            ``curr += A[(i + j) % N, j];``        ``}``         ` `        ``// Update maxDiagonalSum``        ``maxDiagonalSum = Math.Max(maxDiagonalSum,``                                  ``curr);``    ``}``    ``return` `maxDiagonalSum;``}``  ` `// Driver Code``public` `static` `void` `Main()``{``    ``int``[,] mat = { { 1, 1, 2 },``                   ``{ 2, 1, 2 },``                   ``{ 1, 2, 2 } };``      ` `    ``Console.Write(findMaximumDiagonalSumOMatrixf(mat));``}``}` `// This code is contributed by code_hunt`

## Javascript

 ``
Output:
`6`

Time Complexity: O(N2)
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up