Recuento de formas de reorganizar N dígitos y M alfabetos manteniendo todos los alfabetos juntos

Dados dos enteros positivos N y M que representan el recuento de dígitos y alfabetos distintos respectivamente en una string , la tarea de contar el número de formas de reorganizar los caracteres de la string de manera que todos los alfabetos sean adyacentes.

Ejemplos:

Entrada: N = 2, M = 2
Salida: 12
Explicación: Posibles formas de reorganizar los caracteres de una string de modo que todos los alfabetos sean adyacentes: { {N ₁ N ₂ M ₂ M ₁ , N ₂ N ₁ M ₂ M ₁ , N ₂ norte ₁ metro ₁ metro ₂ , norte 1 _norte 2 _metro 1 _metro 2 _, metro _{2 metro 1} norte ₁ norte ₂ , metro ₁ metro ₂ norte ₂N ₁ , M ₁ M ₂ N ₁ N ₂ , M ₂ M ₁ N ₂ N ₁ , N ₁ M ₁ M ₂ N ₂ , N ₂ M ₁ M ₂ N ₁ , N ₁ M ₂ M ₁ N ₂ , N ₂ M ₂ M ₁ N ₁ } }.

Entrada: N = 2, M = 4
Salida: 144

Enfoque ingenuo: el enfoque más simple para resolver este problema es crear una string que consta de N caracteres numéricos distintos y M alfabetos distintos. Ahora, genere todas las permutaciones posibles de la string y verifique si todos los alfabetos de la string son adyacentes o no. Si se encuentra que es cierto, entonces incremente el conteo. Finalmente, imprima el conteo obtenido.

Complejidad de Tiempo: O((N + M)!)
Espacio Auxiliar: O(N + M)

Enfoque eficiente: el problema se puede resolver con base en las siguientes observaciones:

Dado que todos los alfabetos son adyacentes, considere todos los alfabetos como un solo carácter. 
Por lo tanto, el recuento total de formas de reorganizar la string considerando todos los alfabetos en un solo carácter = ((N + 1)!) * (M!) 
 

Siga los pasos a continuación para resolver el problema:

1. Calcule el factorial de N + 1, digamos , X y el factorial de M , digamos, Y.
2. Finalmente, imprima el valor de (X * Y) .

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

// C++ program for the above approach
#include<bits/stdc++.h>
using namespace std;
 
// Function to find the factorial
// of the given number
int fact(int n)
{
    int ans = 1;
 
    for(int i = 2; i <= n; i++)
        ans = ans * i;
    return ans;
}
 
// Function to count ways to rearrange
// characters of the string such that
// all alphabets are adjacent.
int findComb(int N, int M)
{
 
    // Stores factorial of (N + 1)
    int x = fact(N + 1);
 
    // Stores factorial of
    int y = fact(M);
    return (x * y);
 
}
 
// Driver Code
int main()
{
   
// Given a and b
int N = 2;
int M = 2;// Function call
cout<<findComb(N, M);
}
 
// This code is contributed by ipg2016107

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to find the factorial
// of the given number
static int fact(int n)
{
    int ans = 1;
 
    for(int i = 2; i <= n; i++)
        ans = ans * i;
         
    return ans;
}
 
// Function to count ways to rearrange
// characters of the String such that
// all alphabets are adjacent.
static int findComb(int N, int M)
{
     
    // Stores factorial of (N + 1)
    int x = fact(N + 1);
 
    // Stores factorial of
    int y = fact(M);
    return (x * y);
}
 
// Driver Code
public static void main(String[] args)
{
   
    // Given a and b
    int N = 2;
    int M = 2;
     
    // Function call
    System.out.print(findComb(N, M));
}
}
 
// This code is contributed by umadevi9616

# Python program of the above approach
 
import math
 
# Function to find the factorial
# of the given number
 
 
def fact(a):
    return math.factorial(a)
 
# Function to count ways to rearrange
# characters of the string such that
# all alphabets are adjacent.
def findComb(N, M):
 
    # Stores factorial of (N + 1)
    x = fact(N + 1)
     
    # Stores factorial of
    y = fact(M)
    return (x * y)
 
 
# Driver Code
if __name__ == "__main__":
 
    # Given a and b
    N = 2
    M = 2
 
    # Function call
    print(findComb(N, M))

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
    // Function to find the factorial
// of the given number
static int fact(int n)
{
    int ans = 1;
 
    for(int i = 2; i <= n; i++)
        ans = ans * i;
    return ans;
}
 
// Function to count ways to rearrange
// characters of the string such that
// all alphabets are adjacent.
static int findComb(int N, int M)
{
 
    // Stores factorial of (N + 1)
    int x = fact(N + 1);
 
    // Stores factorial of
    int y = fact(M);
    return (x * y);
 
}
 
// Driver Code
public static void Main()
{
   
// Given a and b
int N = 2;
int M = 2;// Function call
Console.Write(findComb(N, M));
 
}
}
 
// This code is contributed by bgangwar59.

<script>
 
        // JavaScript program for the above approach
 
        // Function to find the factorial
        // of the given number
        function fact(n)
        {
            var ans = 1;
 
            for (var i = 2; i <= n; i++)
                ans = ans * i;
            return ans;
        }
 
        // Function to count ways to rearrange
        // characters of the string such that
        // all alphabets are adjacent.
        function findComb(N, M)
        {
 
            // Stores factorial of (N + 1)
            var x = fact(N + 1)
 
            // Stores factorial of
            var y = fact(M)
            return (x * y)
 
        }
         
        // Driver Code
 
        // Given a and b
        var N = 2
        var M = 2
 
        // Function call
        document.write(findComb(N, M))
 
// This code is contributed by Potta Lokesh
    </script>

12

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