Recuento mínimo de árboles binarios completos de modo que el recuento de hojas sea N

Dado un número entero N y un número infinito de árboles binarios completos de diferentes profundidades, la tarea es elegir el número mínimo de árboles tal que la suma del recuento de Nodes hoja en cada uno de los árboles sea N .
Ejemplo: 
 

Entrada: N = 7 
Salida: 3  Los
árboles con profundidades 2, 1 y 0 se pueden seleccionar 
con el número de Nodes de hojas como 4, 2 y 1 respectivamente. 
(4 + 2 + 1) = 7
Entrada: N = 1 
Salida: 1 
 

Enfoque: dado que el número de Nodes hoja en un árbol binario completo siempre es una potencia de dos. Entonces, el problema ahora se reduce a encontrar las potencias de 2 que dan N cuando se suman, de modo que el número total de términos en la suma sea mínimo, que es la respuesta requerida. 
Dado que cada potencia de 2 contiene solo un ‘1’ en su representación binaria, entonces N contendrá el mismo número de ‘1’s que el número de términos en la suma (asumiendo que tomamos el número mínimo de términos). Entonces, el problema se reduce aún más a encontrar la cantidad de bits establecidos en N que se pueden calcular fácilmente utilizando el enfoque utilizado en esta publicación.
A continuación se muestra la implementación del enfoque anterior: 
 

// C++ implementation of the approach
#include <iostream>
using namespace std;
 
// Function to return the minimum
// count of trees required
int minTrees(int n)
{
 
    // To store the count of
    // set bits in n
    int count = 0;
 
    while (n) {
        n &= (n - 1);
        count++;
    }
    return count;
}
 
// Driver code
int main()
{
    int n = 7;
 
    cout << minTrees(n);
 
    return 0;
}

// Java implementation of the approach
class GFG
{
 
// Function to return the minimum
// count of trees required
static int minTrees(int n)
{
 
    // To store the count of
    // set bits in n
    int count = 0;
 
    while (n > 0)
    {
        n &= (n - 1);
        count++;
    }
    return count;
}
 
// Driver code
public static void main(String[] args)
{
    int n = 7;
 
    System.out.print(minTrees(n));
}
}
 
// This code is contributed by 29AjayKumar

# Python3 implementation of the approach
 
# Function to return the minimum
# count of trees required
def minTrees(n):
 
    # To store the count of
    # set bits in n
    count = 0;
 
    while (n):
        n &= (n - 1);
        count += 1;
    return count;
 
# Driver code
if __name__ == '__main__':
    n = 7;
    print(minTrees(n));
 
# This code is contributed by 29AjayKumar

// C# implementation of the approach
using System;
 
class GFG
{
 
    // Function to return the minimum
    // count of trees required
    static int minTrees(int n)
    {
     
        // To store the count of
        // set bits in n
        int count = 0;
     
        while (n > 0)
        {
            n &= (n - 1);
            count++;
        }
        return count;
    }
     
    // Driver code
    public static void Main()
    {
        int n = 7;
     
        Console.Write(minTrees(n));
    }
}
 
// This code is contributed by AnkitRai01

<script>
    // Javascript implementation of the approach
     
    // Function to return the minimum
    // count of trees required
    function minTrees(n)
    {
       
        // To store the count of
        // set bits in n
        let count = 0;
       
        while (n > 0)
        {
            n &= (n - 1);
            count++;
        }
        return count;
    }
     
    let n = 7;
       
      document.write(minTrees(n));
  
 // This code is contributed by divyeshrabadiya07.
</script>

3