Formas de seleccionar hombres y mujeres de un grupo para formar un equipo

Dados cuatro enteros n, w, m y k donde, 
 

• m es el número total de hombres.
• w es el número total de mujeres.
• n es el número total de personas que es necesario seleccionar para formar el equipo.
• k es el número mínimo de hombres que hay que seleccionar.

La tarea es encontrar el número de formas en que se puede formar el equipo.
Ejemplos: 
 

Entrada: m = 2, w = 2, n = 3, k = 1 
Salida: 4 
Hay 2 hombres, 2 mujeres. Necesitamos hacer un equipo de tamaño 3 con al menos un hombre y una mujer. Podemos hacer el equipo de las siguientes maneras. 
m1 m2 w1 
m1 w1 w2 
m2 w1 w2 
m1 m2 w2
Entrada: m = 7, w = 6, n = 5, k = 3 
Salida: 756
Entrada: m = 5, w = 6, n = 6, k = 3 
Salida : 281 
 

Planteamiento: Ya que, tenemos que tomar al menos k hombres. 
 

Totales formas = Formas cuando se seleccionan ‘k’ hombres + Formas cuando se seleccionan ‘k+1’ hombres + … + cuando se seleccionan ‘n’ hombres

. 
Tomando el primer ejemplo de arriba, donde de 7 hombres y 6 mujeres, se debe seleccionar un total de 5 personas con al menos 3 hombres, 
número de formas = (7C3 x 6C2) + (7C4 x 6C1) + (7C5) 
= 7 x 6 x 5 x 6 x 5 + (7C3 x 6C1) + (7C2) 
= 525 + 7 x 6 x 5 x 6 + 7 x 6 
= (525 + 210 + 21) 
= 756
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Returns factorial
// of the number
int fact(int n)
{
    int fact = 1;
    for (int i = 2; i <= n; i++)
        fact *= i;
    return fact;
}
 
// Function to calculate ncr
int ncr(int n, int r)
{
    int ncr = fact(n) / (fact(r) * fact(n - r));
    return ncr;
}
 
// Function to calculate
// the total possible ways
int ways(int m, int w, int n, int k)
{
 
    int ans = 0;
    while (m >= k) {
        ans += ncr(m, k) * ncr(w, n - k);
        k += 1;
    }
 
    return ans;
}
 
// Driver code
int main()
{
 
    int m, w, n, k;
    m = 7;
    w = 6;
    n = 5;
    k = 3;
    cout << ways(m, w, n, k);
}

// Java implementation of the approach
 
import java.io.*;
 
class GFG {
 
// Returns factorial
// of the number
static int fact(int n)
{
    int fact = 1;
    for (int i = 2; i <= n; i++)
        fact *= i;
    return fact;
}
 
// Function to calculate ncr
static int ncr(int n, int r)
{
    int ncr = fact(n) / (fact(r) * fact(n - r));
    return ncr;
}
 
// Function to calculate
// the total possible ways
static int ways(int m, int w, int n, int k)
{
 
    int ans = 0;
    while (m >= k) {
        ans += ncr(m, k) * ncr(w, n - k);
        k += 1;
    }
 
    return ans;
}
 
// Driver code
    public static void main (String[] args) {
         
    int m, w, n, k;
    m = 7;
    w = 6;
    n = 5;
    k = 3;
    System.out.println( ways(m, w, n, k));
    }
}
// This Code is contributed
// by shs

# Python 3 implementation of the approach
 
# Returns factorial of the number
def fact(n):
    fact = 1
    for i in range(2, n + 1):
        fact *= i
    return fact
 
# Function to calculate ncr
def ncr(n, r):
    ncr = fact(n) // (fact(r) * fact(n - r))
    return ncr
 
# Function to calculate
# the total possible ways
def ways(m, w, n, k):
    ans = 0
    while (m >= k):
        ans += ncr(m, k) * ncr(w, n - k)
        k += 1
 
    return ans;
 
# Driver code
m = 7
w = 6
n = 5
k = 3
print(ways(m, w, n, k))
 
# This code is contributed by sahishelangia

// C# implementation of the approach
 
class GFG {
 
// Returns factorial
// of the number
static int fact(int n)
{
    int fact = 1;
    for (int i = 2; i <= n; i++)
        fact *= i;
    return fact;
}
 
// Function to calculate ncr
static int ncr(int n, int r)
{
    int ncr = fact(n) / (fact(r) * fact(n - r));
    return ncr;
}
 
// Function to calculate
// the total possible ways
static int ways(int m, int w, int n, int k)
{
 
    int ans = 0;
    while (m >= k) {
        ans += ncr(m, k) * ncr(w, n - k);
        k += 1;
    }
 
    return ans;
}
 
// Driver code
    static void Main () {
         
    int m, w, n, k;
    m = 7;
    w = 6;
    n = 5;
    k = 3;
    System.Console.WriteLine( ways(m, w, n, k));
    }
}
// This Code is contributed by mits

<?php
// PHP implementation of the approach
 
// Returns factorial of the number
function fact($n)
{
    $fact = 1;
    for ($i = 2; $i <= $n; $i++)
        $fact *= $i;
    return $fact;
}
 
// Function to calculate ncr
function ncr($n, $r)
{
    $ncr = (int)(fact($n) / (fact($r) *
                 fact($n - $r)));
    return $ncr;
}
 
// Function to calculate the total
// possible ways
function ways($m, $w, $n, $k)
{
    $ans = 0;
    while ($m >= $k)
    {
        $ans += ncr($m, $k) *
                ncr($w, $n - $k);
        $k += 1;
    }
 
    return $ans;
}
 
// Driver code
$m = 7;
$w = 6;
$n = 5;
$k = 3;
echo ways($m, $w, $n, $k);
 
// This Code is contributed
// by Mukul Singh

<script>
// javascript implementation of the approach
 
// Returns factorial
// of the number
function fact(n)
{
    var fact = 1;
    for (i = 2; i <= n; i++)
        fact *= i;
    return fact;
}
 
// Function to calculate ncr
function ncr(n , r)
{
    var ncr = fact(n) / (fact(r) * fact(n - r));
    return parseInt(ncr);
}
 
// Function to calculate
// the total possible ways
function ways(m , w , n , k)
{
 
    var ans = 0;
    while (m >= k)
    {
        ans += ncr(m, k) * ncr(w, n - k);
        k += 1;
    }
 
    return parseInt(ans);
}
 
// Driver code
var m, w, n, k;
m = 7;
w = 6;
n = 5;
k = 3;
document.write( ways(m, w, n, k));
 
// This code is contributed by 29AjayKumar.
</script>

756

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

Optimización adicional: el código anterior se puede optimizar utilizando algoritmos más rápidos para el cálculo de coeficientes binomiales .