Formas de colocar 4 elementos en n^2 posiciones de modo que ninguna fila/columna contenga más de uno

Dado un número entero N donde 4 ≤ N ≤ 100 . Hay N líneas verticales y N líneas horizontales. Entonces, hay N ² intersecciones. La tarea es encontrar la cantidad de formas de colocar 4 elementos en estas N ² posiciones de modo que cada fila y columna no contengan más de un elemento.
Ejemplos: 
 

Entrada: N = 4 
 

Salida: 24
Entrada: N = 5 
Salida: 600 
 

Enfoque: El número de formas de elegir 4 líneas horizontales que tendrán elementos de n es ⁿ C ₄ . Hay n formas de colocar un elemento en la primera de estas líneas. Dado el lugar del primer elemento, hay n – 1 formas de colocar un elemento en la segunda de estas líneas porque una de las líneas verticales ya está ocupada. Dados los lugares del primer y segundo elemento, hay n – 2 formas de colocar un elemento en la tercera línea y de la misma manera n – 3 para el cuarto elemento. El número total de formas de colocar elementos en las 4 rutas horizontales seleccionadas es n * (n – 1) * (n – 2) * (n – 3) . Entonces el resultado es ⁿ C ₄* norte * (n – 1) * (n – 2) * (n – 3) .
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 number of ways
// to place 4 items in n^2 positions
long long NumberofWays(int n)
{
    long long x = (1LL * (n) * (n - 1) * (n - 2) * (n - 3))
                  / (4 * 3 * 2 * 1);
    long long y = (1LL * (n) * (n - 1) * (n - 2) * (n - 3));
 
    return (1LL * x * y);
}
 
// Driver code
int main()
{
    int n = 4;
    cout << NumberofWays(n);
 
    return 0;
}

// Java implementation of the approach
class GFG
{
 
// Function to return the number of ways
// to place 4 items in n^2 positions
static long NumberofWays(int n)
{
    long x = (1l * (n) * (n - 1) * (n - 2) * (n - 3))
                / (4 * 3 * 2 * 1);
    long y = (1l * (n) * (n - 1) * (n - 2) * (n - 3));
 
    return (1l * x * y);
}
 
// Driver code
public static void main(String args[])
{
    int n = 4;
    System.out.println( NumberofWays(n));
}
}
 
// This code is contributed by Arnab Kundu

# python implementation of the approach
 
# Function to return the number of ways
# to place 4 items in n^2 positions
def NumbersofWays(n):
    x = (n * (n - 1) * (n - 2) * (n - 3)) // (4 * 3 * 2 * 1)
    y = n * (n - 1) * (n - 2) * (n - 3)
 
    return x * y
 
# Driver code
n = 4
print(NumbersofWays(n))
 
# This code is contributed by Shrikant13

// C# implementation of the approach
using System;
 
class GFG
{
 
// Function to return the number of ways
// to place 4 items in n^2 positions
public static long NumberofWays(int n)
{
    long x = (1l * (n) * (n - 1) * (n - 2) *
               (n - 3)) / (4 * 3 * 2 * 1);
    long y = (1l * (n) * (n - 1) * (n - 2) *
                (n - 3));
 
    return (1l * x * y);
}
 
// Driver code
public static void Main(string[] args)
{
    int n = 4;
    Console.WriteLine(NumberofWays(n));
}
}
 
// This code is contributed by Shrikant13

<?php
// PHP implementation of the approach
 
// Function to return the number of ways
// to place 4 items in n^2 positions
function NumberofWays($n)
{
    $x = (1 * ($n) * ($n - 1) *
                     ($n - 2) * ($n - 3)) /
                          (4 * 3 * 2 * 1);
    $y = (1 * ($n) * ($n - 1) *
                     ($n - 2) * ($n - 3));
 
    return (1 * $x * $y);
}
 
// Driver code
$n = 4;
echo NumberofWays($n);
 
// This code is contributed by mits
?>

<script>
 
      // JavaScript implementation of the approach
      // Function to return the number of ways
      // to place 4 items in n^2 positions
      function NumberofWays(n) {
        var x = (1 * n * (n - 1) * (n - 2) * (n - 3)) /
        (4 * 3 * 2 * 1);
        var y = 1 * n * (n - 1) * (n - 2) * (n - 3);
 
        return 1 * x * y;
      }
 
      // Driver code
      var n = 4;
      document.write(NumberofWays(n));
       
</script>

24

Complejidad de tiempo: O(1)

Espacio Auxiliar: O(1)