Posición total a la que puede llegar el rey en un tablero de ajedrez exactamente en M jugadas | conjunto 2

Dada la posición del rey en un tablero de ajedrez de 8 X 8 , la tarea es contar el número total de casillas que puede visitar el rey en m jugadas. La posición del rey se indica mediante el número de fila y columna. 
Nota: La plaza que actualmente adquiere el rey ya está visitada y se contará en el resultado.
Ejemplos: 
 

Entrada: r = 4, c = 4, m = 1 
Salida: 9
Entrada: r = 4, c = 4, m = 2 
Salida: 25 

Aproximación: Un rey puede moverse una casilla en cualquier dirección (es decir, horizontal, vertical y diagonalmente). Entonces, en un movimiento, el rey puede visitar sus casillas adyacentes. 
 

Por lo tanto, un cuadrado que está dentro de m unidades de distancia (considerando 1 cuadrado como 1 unidad de distancia) desde la posición actual del rey se puede visitar en m movimientos. 
Para todos los cuadrados del tablero de ajedrez, verifique si un cuadrado en particular está a una distancia de m unidad o menos de la posición actual del Rey.

1. Incremente el conteo, si el paso 1 es verdadero.
2. Imprime el conteo

A continuación se muestra la implementación del enfoque anterior:

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of squares
// that can be visited by king in m moves
int countSquares(int r, int c, int m)
{
 
    // To store the count of squares
    int squares = 0;
 
    // Check all squares of
    // the chessboard
    for (int i = 1; i <= 8; i++) {
        for (int j = 1; j <= 8; j++) {
 
            // Check if square (i, j) is
            // at a distance <= m units
            // from king's current position
            if (max(abs(i - r), abs(j - c)) <= m)
                squares++;
        }
    }
 
    // Return count of squares
    return squares;
}
 
// Driver code
int main()
{
    int r = 4, c = 4, m = 1;
 
    cout << countSquares(r, c, m) << endl;
 
    return 0;
}

// Java implementation of the approach
class GFG {
 
    // Function to return the count of squares
    // that can be visited by king in m moves
    static int countSquares(int r, int c, int m)
    {
        // To store the count of squares
        int squares = 0;
 
        // Check all squares of
        // the chessboard
        for (int i = 1; i <= 8; i++) {
            for (int j = 1; j <= 8; j++) {
 
                // Check if square (i, j) is
                // at a distance <= m units
                // from king's current position
                if (Math.max(Math.abs(i - r), Math.abs(j - c)) <= m)
                    squares++;
            }
        }
 
        // Return count of squares
        return squares;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int r = 4, c = 4, m = 1;
        System.out.print(countSquares(r, c, m));
    }
}

// C# implementation of the approach
using System;
class GFG {
 
    // Function to return the count of squares
    // that can be visited by king in m moves
    static int countSquares(int r, int c, int m)
    {
        // To store the count of squares
        int squares = 0;
 
        // Check all squares of
        // the chessboard
        for (int i = 1; i <= 8; i++) {
            for (int j = 1; j <= 8; j++) {
 
                // Check if square (i, j) is
                // at a distance <= m units
                // from king's current position
                if (Math.Max(Math.Abs(i - r), Math.Abs(j - c)) <= m)
                    squares++;
            }
        }
 
        // Return count of squares
        return squares;
    }
 
    // Driver code
    public static void Main()
    {
        int r = 4, c = 4, m = 1;
        Console.Write(countSquares(r, c, m));
    }
}

# Python implementation of the approach
 
# Function to return the count of squares
# that can be visited by king in m moves
def countSquares(r, c, m):
 
    # To store the count of squares
    squares = 0
     
    # Check all squares of
    # the chessboard
    for i in range (1, 9):
        for j in range (1, 9):
             
            # Check if square (i, j) is
            # at a distance <= m units
            # from king's current position
            if(max(abs(i - r), abs(j - c)) <= m):
                squares = squares + 1
         
    # Return count of squares
    return squares
 
# Driver code
r = 4
c = 4
m = 1
 
print(countSquares(r, c, m));

<?php
// PHP implementation of the approach
 
// Function to return the count of squares
// that can be visited by king in m moves
function countSquares($r, $c, $m)
{
 
    // To store the count of squares
    $squares = 0;
 
    // Check all squares of
    // the chessboard
    for ($i = 1; $i <= 8; $i++)
    {
        for ($j = 1; $j <= 8; $j++)
        {
 
            // Check if square (i, j) is
            // at a distance <= m units
            // from king's current position
            if (max(abs($i - $r),
                    abs($j - $c)) <= $m)
                $squares++;
        }
    }
 
    // Return count of squares
    return $squares;
}
 
// Driver code
$r = 4;
$c = 4;
$m = 1;
 
echo countSquares($r, $c, $m);
 
// This code is contributed by Ryuga
?>

<script>
 
// Javascript implementation of the approach 
 
    // Function to return the count of squares
    // that can be visited by king in m moves
    function countSquares(r, c, m)
    {
        // To store the count of squares
        let squares = 0;
   
        // Check all squares of
        // the chessboard
        for (let i = 1; i <= 8; i++) {
            for (let j = 1; j <= 8; j++) {
   
                // Check if square (i, j) is
                // at a distance <= m units
                // from king's current position
                if (Math.max(Math.abs(i - r), Math.abs(j - c)) <= m)
                    squares++;
            }
        }
   
        // Return count of squares
        return squares;
    }
 
// Driver Code
 
         let r = 4, c = 4, m = 1;
        document.write(countSquares(r, c, m));
            
</script>

9

Complejidad de tiempo: O(1), ya que el ciclo se ejecuta un total de 64 veces, eso es solo tiempo constante.
Espacio Auxiliar: O(1), ya que no se ha ocupado ningún espacio extra.