Encuentra el área de la superficie de una figura 3D

Dada una array N*M A[][] que representa una figura 3D. La altura del edificio en  es  . Encuentra el área de la superficie de la figura.

Ejemplos: 

Input : N = 1, M = 1   A[][] = { {1} }
Output : 6

Explanation : 
The total surface area is 6 i.e 6 side of 
the figure and each are of height 1.

Input : N = 3, M = 3   A[][] = { {1, 3, 4},
                                 {2, 2, 3},
                                 {1, 2, 4} }
Output : 60

Enfoque: para encontrar el área de la superficie, debemos considerar la contribución de los seis lados de la figura 3D dada. Vamos a resolver las preguntas en parte para que sea fácil. La base de la figura siempre contribuirá con N*M al área de superficie total de la figura, y la parte superior de la figura contribuirá con la misma área de N*M. Ahora, para calcular el área aportada por los muros, sacaremos la diferencia absoluta entre la altura de dos muros adyacentes. La diferencia será la aportación en la superficie total.

A continuación se muestra la implementación de la idea anterior: 

// CPP program to find the Surface area of a 3D figure
#include <bits/stdc++.h>
using namespace std;
 
// Declaring the size of the matrix
const int M = 3;
const int N = 3;
 
// Absolute Difference between the height of
// two consecutive blocks
int contribution_height(int current, int previous)
{
    return abs(current - previous);
}
 
// Function To calculate the Total surfaceArea.
int surfaceArea(int A[N][M])
{
    int ans = 0;
 
    // Traversing the matrix.
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
 
            /* If we are traveling the topmost row in the
            matrix, we declare the wall above it as 0
            as there is no wall above it. */
            int up = 0;
 
            /* If we are traveling the leftmost column in the
            matrix, we declare the wall left to it as 0
            as there is no wall left it. */
            int left = 0;
 
            // If its not the topmost row
            if (i > 0)
                up = A[i - 1][j];
 
            // If its not the leftmost column
            if (j > 0)
                left = A[i][j - 1];
 
            // Summing up the contribution of by
            // the current block
            ans += contribution_height(A[i][j], up)
                    + contribution_height(A[i][j], left);
 
            /* If its the rightmost block of the matrix
               it will contribute area equal to its height
               as a wall on the right of the figure */
            if (i == N - 1)
                ans += A[i][j];
 
            /* If its the lowest block of the matrix it will
               contribute area equal to its height as a wall
               on the bottom of the figure */
            if (j == M - 1)
                ans += A[i][j];
        }
    }
 
    // Adding the contribution by the base and top of the figure
    ans += N * M * 2;
    return ans;
}
 
// Driver program
int main()
{
    int A[N][M] = { { 1, 3, 4 },
                    { 2, 2, 3 },
                    { 1, 2, 4 } };
    cout << surfaceArea(A) << endl;
    return 0;
}

// Java program to find the Surface
// area of a 3D figure
 
class GFG
{
    // Declaring the size of the matrix
    static final int M=3;
    static final int N=3;
     
    // Absolute Difference between the height of
    // two consecutive blocks
    static int contribution_height(int current, int previous)
    {
        return Math.abs(current - previous);
    }
     
    // Function To calculate the Total surfaceArea.
    static int surfaceArea(int A[][])
    {
        int ans = 0;
     
        // Traversing the matrix.
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < M; j++) {
     
                /* If we are traveling the topmost
                row in the matrix, we declare the
                wall above it as 0 as there is no
                wall above it. */
                int up = 0;
     
                /* If we are traveling the leftmost
                column in the matrix, we declare the
                wall left to it as 0as there is no
                wall left it. */
                int left = 0;
     
                // If its not the topmost row
                if (i > 0)
                    up = A[i - 1][j];
     
                // If its not the leftmost column
                if (j > 0)
                    left = A[i][j - 1];
     
                // Summing up the contribution of by
                // the current block
                ans += contribution_height(A[i][j], up)
                       + contribution_height(A[i][j], left);
     
                /* If its the rightmost block of the matrix
                it will contribute area equal to its height
                as a wall on the right of the figure */
                if (i == N - 1)
                    ans += A[i][j];
     
                /* If its the lowest block of the
                matrix it will contribute area equal
                to its height as a wall on
                 the bottom of the figure */
                if (j == M - 1)
                    ans += A[i][j];
            }
        }
     
        // Adding the contribution by
        // the base and top of the figure
        ans += N * M * 2;
        return ans;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int A[][] = {{ 1, 3, 4 },
                     { 2, 2, 3 },
                     { 1, 2, 4 } };
        System.out.println(surfaceArea(A));
    }
}
 
// This code is contributed By Anant Agarwal.

# Python3 program to find the
# Surface area of a 3D figure
 
 
# Declaring the size
# of the matrix
M = 3;
N = 3;
 
# Absolute Difference
# between the height of
# two consecutive blocks
def contribution_height(current, previous):
    return abs(current - previous);
 
# Function To calculate
# the Total surfaceArea.
def surfaceArea(A):
    ans = 0;
 
    # Traversing the matrix.
    for i in range(N):
        for j in range(M):
 
            # If we are traveling the
            # topmost row in the matrix,
            # we declare the wall above it
            # as 0 as there is no wall
            # above it.
            up = 0;
 
            # If we are traveling the
            # leftmost column in the
            # matrix, we declare the wall
            # left to it as 0 as there is
            # no wall left it.
            left = 0;
 
            # If its not the topmost row
            if (i > 0):
                up = A[i - 1][j];
 
            # If its not the
            # leftmost column
            if (j > 0):
                left = A[i][j - 1];
 
            # Summing up the
            # contribution of by
            # the current block
            ans += contribution_height(A[i][j], up)+contribution_height(A[i][j], left);
             
            # If its the rightmost block
            # of the matrix it will contribute
            # area equal to its height as a
            # wall on the right of the figure */
            if (i == N - 1):
                ans += A[i][j];
 
            # If its the lowest block
            # of the matrix it will
            # contribute area equal to
            # its height as a wall on
            # the bottom of the figure
            if (j == M - 1):
                ans += A[i][j];
 
    # Adding the contribution by
    # the base and top of the figure
    ans += N * M * 2;
    return ans;
 
# Driver Code
A = [[1, 3, 4],[2, 2, 3],[1, 2, 4]];
print(surfaceArea(A));
 
# This code is contributed By mits

// C# program to find the
// Surface area of a 3D figure
using System;
 
class GFG
{
    // Declaring the size of the matrix
    static int M=3;
    static int N=3;
     
    // Absolute Difference between the
    // height of two consecutive blocks
    static int contribution_height(int current, int previous)
    {
        return Math.Abs(current - previous);
    }
     
    // Function To calculate the
    // Total surfaceArea.
    static int surfaceArea(int [,]A)
    {
        int ans = 0;
     
    // Traversing the matrix.
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < M; j++) {
     
    // If we are traveling the topmost
    // row in the matrix, we declare the
    // wall above it as 0 as there is no
    // wall above it.
                int up = 0;
     
    // If we are traveling the leftmost
    // column in the matrix, we declare
    // the wall left to it as 0as there
    // is no wall left it.
                int left = 0;
     
    // If its not the topmost row
                if (i > 0)
                    up = A[i - 1,j];
     
    // If its not the leftmost column
                if (j > 0)
                    left = A[i,j - 1];
     
    // Summing up the contribution 
    // of by the current block
            ans += contribution_height(A[i,j], up)
                + contribution_height(A[i,j], left);
     
    // If its the rightmost block of the
    // matrix it will contribute area equal
    // to its height as a wall on the right
    // of the figure
                if (i == N - 1)
                    ans += A[i,j];
     
    // If its the lowest block of the
    // matrix it will contribute area 
    // equal to its height as a wall
    // on the bottom of the figure
                if (j == M - 1)
                    ans += A[i,j];
            }
        }
     
    // Adding the contribution by the
    // base and top of the figure
        ans += N * M * 2;
        return ans;
    }
     
    // Driver code
    public static void Main ()
    {
        int [,]A = {{ 1, 3, 4 },
                    { 2, 2, 3 },
                    { 1, 2, 4 } };
        Console.WriteLine(surfaceArea(A));
    }
}
 
// This code is contributed By vt_m.

<?php
// PHP program to find the
// Surface area of a 3D figure
 
 
// Declaring the size
// of the matrix
$M = 3;
$N = 3;
 
// Absolute Difference
// between the height of
// two consecutive blocks
function contribution_height($current,
                             $previous)
{
    return abs($current - $previous);
}
 
// Function To calculate
// the Total surfaceArea.
function surfaceArea($A)
{
    global $M;
    global $N;
    $ans = 0;
 
    // Traversing the matrix.
    for ($i = 0; $i < $N; $i++)
    {
        for ($j = 0; $j < $M; $j++)
        {
 
            /* If we are traveling the
            topmost row in the matrix,
            we declare the wall above it
            as 0 as there is no wall
            above it. */
            $up = 0;
 
            /* If we are traveling the
            leftmost column in the
            matrix, we declare the wall
            left to it as 0 as there is
            no wall left it. */
            $left = 0;
 
            // If its not the topmost row
            if ($i > 0)
                $up = $A[$i - 1][$j];
 
            // If its not the
            // leftmost column
            if ($j > 0)
                $left = $A[$i][$j - 1];
 
            // Summing up the
            // contribution of by
            // the current block
            $ans += contribution_height($A[$i][$j], $up) +
                    contribution_height($A[$i][$j], $left);
             
            /* If its the rightmost block
            of the matrix it will contribute
            area equal to its height as a
            wall on the right of the figure */
            if ($i == $N - 1)
                $ans += $A[$i][$j];
 
            /* If its the lowest block
               of the matrix it will
               contribute area equal to
               its height as a wall on
               the bottom of the figure */
            if ($j == $M - 1)
                $ans += $A[$i][$j];
        }
    }
 
    // Adding the contribution by
    // the base and top of the figure
    $ans += $N * $M * 2;
    return $ans;
}
 
// Driver Code
$A = array(array(1, 3, 4),
           array(2, 2, 3),
           array(1, 2, 4));
echo surfaceArea($A);
 
// This code is contributed By mits
?>

<script>
 
// JavaScript program to find the Surface
// area of a 3D figure
 
// Declaring the size of the matrix
    let M=3;
    let N=3;
       
    // Absolute Difference between the height of
    // two consecutive blocks
    function contribution_height(current, previous)
    {
        return Math.abs(current - previous);
    }
       
    // Function To calculate the Total surfaceArea.
    function surfaceArea( A)
    {
        let ans = 0;
       
        // Traversing the matrix.
        for (let i = 0; i < N; i++)
        {
            for (let j = 0; j < M; j++) {
       
                /* If we are traveling the topmost
                row in the matrix, we declare the
                wall above it as 0 as there is no
                wall above it. */
                let up = 0;
       
                /* If we are traveling the leftmost
                column in the matrix, we declare the
                wall left to it as 0as there is no
                wall left it. */
                let left = 0;
       
                // If its not the topmost row
                if (i > 0)
                    up = A[i - 1][j];
       
                // If its not the leftmost column
                if (j > 0)
                    left = A[i][j - 1];
       
                // Summing up the contribution of by
                // the current block
                ans += contribution_height(A[i][j], up)
                       + contribution_height(A[i][j], left);
       
                /* If its the rightmost block of the matrix
                it will contribute area equal to its height
                as a wall on the right of the figure */
                if (i == N - 1)
                    ans += A[i][j];
       
                /* If its the lowest block of the
                matrix it will contribute area equal
                to its height as a wall on
                 the bottom of the figure */
                if (j == M - 1)
                    ans += A[i][j];
            }
        }
       
        // Adding the contribution by
        // the base and top of the figure
        ans += N * M * 2;
        return ans;
    }
 
// Driver code
         
        let A = [[ 1, 3, 4 ],
                     [ 2, 2, 3 ],
                     [ 1, 2, 4 ]];
        document.write(surfaceArea(A));
                   
</script>

60

Complejidad de tiempo: O (N * M), ya que el código anterior se ha iterado a través de dos bucles. 
Espacio Auxiliar: O(N*M), para la array 2D de tamaño N y M.