Find the sum of the diagonal elements of the given N X N spiral matrix
Given N which is the size of the N X N spiral matrix of the form:
16 15 14 13
5 4 3 12
6 1 2 11
7 8 9 10
The task is to find the sum of the diagonal elements of this matrix.
Examples:
Input: N = 3
Output: 25
5 4 3
6 1 2
7 8 9
The sum of elements along its two diagonals will be
1 + 3 + 7 + 5 + 9 = 25
Input: N = 5
Output: 101
Recursive Approach: The idea behind the solution is to use recursion to compute sum of the diagonal elements.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int findSum( int n)
{
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
int ans = 0;
for ( int i = 2; i <= n; i++) {
ans =(4 * (i * i))
- 6 * (i - 1) + findSum(n - 2);
}
return ans;
}
int main()
{
int n = 4;
cout << findSum(n);
return 0;
}
|
Java
import java.util.*;
public class GFG
{
static int findSum( int n)
{
if (n == 0 ) {
return 0 ;
}
if (n == 1 ) {
return 1 ;
}
int ans = 0 ;
for ( int i = 2 ; i <= n; i++) {
ans =( 4 * (i * i))
- 6 * (i - 1 ) + findSum(n - 2 );
}
return ans;
}
public static void main(String args[])
{
int n = 4 ;
System.out.println(findSum(n));
}
}
|
Python3
def findSum(n):
if (n = = 0 ):
return 0
if (n = = 1 ):
return 1
ans = 0
for i in range ( 2 , n + 1 , 1 ):
ans = (( 4 * (i * i)) - 6 *
(i - 1 ) + findSum(n - 2 ))
return ans
if __name__ = = '__main__' :
n = 4
print (findSum(n))
|
C#
using System;
class GFG
{
static int findSum( int n)
{
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
int ans = 0;
for ( int i = 2; i <= n; i++) {
ans =(4 * (i * i))
- 6 * (i - 1) + findSum(n - 2);
}
return ans;
}
public static void Main()
{
int n = 4;
Console.Write(findSum(n));
}
}
|
Javascript
<script>
function findSum(n)
{
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
let ans = 0;
for (let i = 2; i <= n; i++) {
ans =(4 * (i * i))
- 6 * (i - 1) + findSum(n - 2);
}
return ans;
}
let n = 4;
document.write(findSum(n));
</script>
|
Time Complexity: O(2N)
Auxiliary Space: O(1)
Dynamic Programming Approach: Idea behind the solution is to use the concept of Dynamic Programming. We will use array dp[] to store our solution. N given in the problem can either be even or odd.
When i is odd, we have to add only 4 corner elements in dp[i – 2].
dp[i] = dp[i – 2] + (i – 2) * (i – 2) + (i – 1) + (i – 2) * (i – 2) + 2 * (i – 1) + (i – 2) * (i – 2) + 3 * (i – 1) + (i – 2) * (i – 2) + 4 * (i – 1)
dp[i] = dp[i – 2] + 4 * (i – 2) * (i – 2) + 10 * (i – 1)
dp[i] = dp[i – 2] + 4 * (i) * (i) – 6 * (i – 1)
Similarly, we can check that the above formula is true when i is even.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int findSum( int n)
{
int dp[n + 1];
dp[1] = 1;
dp[0] = 0;
for ( int i = 2; i <= n; i++) {
dp[i] = (4 * (i * i))
- 6 * (i - 1) + dp[i - 2];
}
return dp[n];
}
int main()
{
int n = 4;
cout << findSum(n);
return 0;
}
|
Java
class GFG
{
static int findSum( int n)
{
int [] dp = new int [n + 1 ];
dp[ 1 ] = 1 ;
dp[ 0 ] = 0 ;
for ( int i = 2 ; i <= n; i++)
{
dp[i] = ( 4 * (i * i)) - 6 *
(i - 1 ) + dp[i - 2 ];
}
return dp[n];
}
public static void main(String args[])
{
int n = 4 ;
System.out.println(findSum(n));
}
}
|
Python3
def findSum(n):
dp = [ 0 for i in range (n + 1 )]
dp[ 1 ] = 1
dp[ 0 ] = 0
for i in range ( 2 , n + 1 , 1 ):
dp[i] = (( 4 * (i * i)) - 6 *
(i - 1 ) + dp[i - 2 ])
return dp[n]
if __name__ = = '__main__' :
n = 4
print (findSum(n))
|
C#
class GFG
{
static int findSum( int n)
{
int [] dp = new int [n + 1];
dp[1] = 1;
dp[0] = 0;
for ( int i = 2; i <= n; i++)
{
dp[i] = (4 * (i * i))
- 6 * (i - 1) + dp[i - 2];
}
return dp[n];
}
static void Main()
{
int n = 4;
System.Console.WriteLine(findSum(n));
}
}
|
PHP
<?php
function findSum( $n )
{
$dp = array ();
$dp [1] = 1;
$dp [0] = 0;
for ( $i = 2; $i <= $n ; $i ++)
{
$dp [ $i ] = (4 * ( $i * $i )) - 6 *
( $i - 1) + $dp [ $i - 2];
}
return $dp [ $n ];
}
$n = 4;
echo findSum( $n );
?>
|
Javascript
<script>
let findSum(n)
{
let dp = new Array(n + 1);
dp[1] = 1;
dp[0] = 0;
for (let i = 2; i <= n; i++) {
dp[i] = (4 * (i * i))
- 6 * (i - 1) + dp[i - 2];
}
return dp[n];
}
let n = 4;
document.write(findSum(n));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Last Updated :
07 Aug, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...