Cuente los arreglos de N personas alrededor de una mesa circular de modo que K personas siempre se sienten juntas

Dados los números enteros N y K , la tarea es encontrar el número de arreglos posibles de N personas alrededor de una mesa circular tal que K personas siempre se sientan juntas.

Nota: Como la respuesta puede ser muy grande, devuélvela módulo 10 ⁹ + 7

Ejemplos:

Entrada: N = 4, K = 3
Salida: 6
Explicación: Si 3 personas siempre se sientan juntas (digamos 1, 2 y 3), entonces los arreglos posibles pueden ser
{1, 2, 3, 4}, {1, 3, 2 , 4}, {2, 1, 3, 4}, {2, 3, 1, 4}, {3, 2, 1, 4}, {3, 1, 2, 4}.
Como no hay principio ni final en un arreglo circular y 
los arreglos se basan en posiciones relativas, podemos considerar que
4 siempre está fijo en la última posición.

Entrada: N = 8, K = 3
Salida: 720 

Planteamiento: Este problema se puede resolver con base en la siguiente idea matemática:

En un arreglo circular no hay principio ni final y los arreglos se basan en posiciones relativas.
Entonces, se puede considerar que cualquiera de las personas siempre está sentada en una posición fija y todas las demás posiciones son relativas a esa posición. 
¡Así que el total de arreglos posibles de N personas alrededor de una mesa circular es (N-1)!

Como las personas K siempre se sentarán juntas, pueden considerarse un grupo o una sola unidad.
Así que la unidad total ahora X = (N – K + 1). Los posibles arreglos totales de estas muchas personas son:
(X – 1)! = (N – K)!

¡Las personas de este único grupo se pueden organizar en K! formas para cada uno de los arreglos posibles.
por lo tanto arreglos posibles totales = K! * (N-K)!

• Calcular el factorial de K .
• Calcular el factorial de (N – K).
• Multiplique estos dos valores para obtener la respuesta real.

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

// C++ code to implement the approach
#include <iostream>
using namespace std;
 
const int mod = 1000000007;
 
// Function to compute factorial of a number
int fac(int f) {
    int fac = 1;
    for (int i = 1; i <= f; i++)
        fac = (fac * i) % mod;
    return fac;
}
 
// Function to find number of ways
int Ways(int n, int k)
{
   
    // Find (n-k) factorial and k factorial
    // Return product of these two
    return (fac(n - k) * fac(k)) % mod;
}
   
// Driver code 
int main() {
    int N = 8;
    int K = 3;
 
 
    cout <<    Ways(N, K);
    return 0;
}
 
// This code is contributed by ANKITKUMAR34.

// Java code for the above approach
 
import java.io.*;
 
class GFG {
 
    static int mod = 1000000007;
 
    // Function to compute factorial of a number
    static int fac(int f)
    {
        int fac = 1;
        for (int i = 1; i <= f; i++)
            fac = (fac * i) % mod;
        return fac;
    }
 
    // Function to find number of ways
    static int Ways(int n, int k)
    {
 
        // Find (n-k) factorial and k factorial
        // Return product of these two
        return (fac(n - k) * fac(k)) % mod;
    }
 
    public static void main(String[] args)
    {
        int N = 8;
        int K = 3;
 
        System.out.println(Ways(N, K));
    }
}
 
// This code is contributed by Potta Lokesh

# Python code to implement the approach
 
mod = 1000000007
 
# Function to compute factorial of a number
def fac(f):
    fac = 1
    for i in range(2, f + 1):
        fac = (fac * i) % mod
    return fac   
 
# Function to find number of ways
def Ways(n, k):
    # Find (n-k) factorial and k factorial
    # Return product of these two
    return (fac(n - k) * fac(k)) % mod
 
   
# Driver code
if __name__ == '__main__':
    N = 8
    K = 3
    print(Ways(N, K));

// C# code to implement the above approach
using System;
 
public class GFG
{
 
  static int mod = 1000000007;
 
  // Function to compute factorial of a number
  static int fac(int f) {
    int fac = 1;
    for (int i = 1; i <= f; i++)
      fac = (fac * i) % mod;
    return fac;
  }
 
  // Function to find number of ways
  static int Ways(int n, int k)
  {
 
    // Find (n-k) factorial and k factorial
    // Return product of these two
    return (fac(n - k) * fac(k)) % mod;
  }
 
  // Driver code 
  static public void Main (){
    int N = 8;
    int K = 3;
 
    Console.WriteLine(Ways(N, K));
  }
}
 
// This code is contributed by AnkThon

<script>
// Javascript code to implement the approach
 
 
let mod = 1000000007;
 
// Function to compute factorial of a number
function fac(f) {
  let fac = 1;
  for (let i = 1; i <= f; i++)
    fac = (fac * i) % mod;
  return fac;
}
 
// Function to find number of ways
function Ways(n, k) {
 
  // Find (n-k) factorial and k factorial
  // Return product of these two
  return (fac(n - k) * fac(k)) % mod;
}
 
// Driver code 
 
let N = 8;
let K = 3;
 
 
document.write(Ways(N, K))
 
// This code is contributed by Saurabh Jaiswal
 
</script>

720

Complejidad temporal: O(N)
Espacio auxiliar: O(1)