# Maximize sum of diagonal of a matrix by rotating all rows or all columns

• Difficulty Level : Easy
• Last Updated : 01 Oct, 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)

My Personal Notes arrow_drop_up