Encuentra el producto de la suma de dos diagonales de una array cuadrada

Dada una estera de array cuadrada que consta de números enteros de tamaño NxN , la tarea es calcular el producto entre las sumas de su diagonal.
Ejemplos: 
 

Input: mat[][] = {{5, 8, 1}, 
                   {5, 10, 3}, 
                   {-6, 17, -9}}
Output: 30
Sum of primary diagonal = 5 + 10 + (-9) = 6.
Sum of secondary diagonal = 1 + 10 + (-6) = 5.
Product = 6 * 5 = 30.

Input: mat[][] = {{22, -8, 11}, 
                   {55, 87, -1}, 
                   {-61, 69, 19}}
Output: 4736

Enfoque ingenuo: recorrer toda la array y encontrar los elementos diagonales . Calcular las sumas a través de las dos diagonales de una array cuadrada . Luego, basta con tomar el producto de las dos sumas obtenidas. 
Complejidad temporal: O(N ² )
Enfoque ingenuo: Atraviese solo los elementos diagonales en lugar de toda la array observando el patrón en los índices de los elementos diagonales. 
A continuación se muestra la implementación de este enfoque: 
 

// C++ program to find the product
// of the sum of diagonals.
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the product
// of the sum of diagonals.
long long product(vector<vector<int>> &mat, int n)
{
    // Initialize sums of diagonals
    long long d1 = 0, d2 = 0;
 
    for (int i = 0; i < n; i++)
    {
        d1 += mat[i][i];
        d2 += mat[i][n - i - 1];
    }
     
    // Return the answer
    return 1LL * d1 * d2;
}
 
// Driven code
int main()
{
    vector<vector<int>> mat = {{ 5, 8, 1},
                               { 5, 10, 3},
                               { -6, 17, -9}};
                                
    int n = mat.size();
     
    // Function call
    cout << product(mat, n);
     
    return 0;
}

// Java program to find the product
// of the sum of diagonals.
 
 
class GFG{
  
// Function to find the product
// of the sum of diagonals.
static long product(int [][]mat, int n)
{
    // Initialize sums of diagonals
    long d1 = 0, d2 = 0;
  
    for (int i = 0; i < n; i++)
    {
        d1 += mat[i][i];
        d2 += mat[i][n - i - 1];
    }
      
    // Return the answer
    return 1L * d1 * d2;
}
  
// Driven code
public static void main(String[] args)
{
    int [][]mat = {{ 5, 8, 1},
                               { 5, 10, 3},
                               { -6, 17, -9}};
                                 
    int n = mat.length;
      
    // Function call
    System.out.print(product(mat, n));
      
}
}
 
// This code is contributed by 29AjayKumar

# Python3 program to find the product
# of the sum of diagonals.
 
# Function to find the product
# of the sum of diagonals.
def product(mat,n):
 
    # Initialize sums of diagonals
    d1 = 0
    d2 = 0
 
    for i in range(n):
 
        d1 += mat[i][i]
        d2 += mat[i][n - i - 1]
 
    # Return the answer
    return d1 * d2
 
 
# Driven code
if __name__ == '__main__':
    mat = [[5, 8, 1],
        [5, 10, 3],
        [-6, 17, -9]]
 
    n = len(mat)
 
    # Function call
    print(product(mat, n))
     
# This code is contributed by mohit kumar 29   

// C# program to find the product
// of the sum of diagonals.
using System;
 
class GFG{
 
// Function to find the product
// of the sum of diagonals.
static long product(int [,]mat, int n)
{
    // Initialize sums of diagonals
    long d1 = 0, d2 = 0;
 
    for (int i = 0; i < n; i++)
    {
        d1 += mat[i, i];
        d2 += mat[i, n - i - 1];
    }
     
    // Return the answer
    return 1L * d1 * d2;
}
 
// Driven code
public static void Main(String[] args)
{
    int [,]mat = {{ 5, 8, 1},
                    { 5, 10, 3},
                    { -6, 17, -9}};
                                 
    int n = mat.GetLength(0);
     
    // Function call
    Console.Write(product(mat, n));
}
}
 
// This code is contributed by Princi Singh

<script>
// Javascript program to find the product
// of the sum of diagonals.
 
// Function to find the product
// of the sum of diagonals.
function product(mat, n)
{
    // Initialize sums of diagonals
    let d1 = 0, d2 = 0;
 
    for (let i = 0; i < n; i++)
    {
        d1 += mat[i][i];
        d2 += mat[i][n - i - 1];
    }
     
    // Return the answer
    return d1 * d2;
}
 
// Driven code
    let mat = [[ 5, 8, 1],
                               [ 5, 10, 3],
                               [ -6, 17, -9]];
                                
    let n = mat.length;
     
    // Function call
    document.write(product(mat, n));
 
// This code is contributed by rishavmahato348.
</script>

30

Complejidad del tiempo: O(N)