Minimice las operaciones de eliminación de elementos de array 2i -1 para vaciar la array dada

Dada una array arr[] de tamaño N , la tarea es vaciar la array dada eliminando 2 ⁱ – 1 elementos de la array en cada operación ( i es cualquier número entero positivo ). Encuentre el número mínimo de operaciones requeridas.

Ejemplos:

Entrada: arr[] = { 2, 3, 4 } 
Salida: 1 
Explicación: 
Eliminar (2 ² – 1) elementos, es decir, { arr[0], arr[1], arr[2] } modifica arr[] a { } 
Dado que no quedan elementos en la array, la salida requerida es 1.

Entrada: arr[] = { 1, 2, 3, 4 } 
Salida: 2 
Explicación: 
Eliminando (2 ¹ – 1) elemento, es decir, { arr[0] } modifica arr[] a { 2, 3, 4 } 
Eliminando ( 2 ² – 1) elementos, es decir, { arr[0], arr[1], arr[2] } modifica arr[] a { } 
Dado que no quedan elementos en la array, el resultado requerido es 2.

Enfoque: El problema se puede resolver usando la técnica Greedy . La idea es eliminar siempre el máximo número posible (2 ⁱ – 1 ) de elementos de la array. Siga los pasos a continuación para resolver el problema:

• Inicialice una variable, digamos cntSteps , para almacenar el recuento mínimo de operaciones requeridas para vaciar la array dada.
• Eliminar N elementos de la array modifica arr[] a una array de longitud 0 . Por lo tanto, incremente el valor de N en 1 .
• Atraviese cada bit de N usando la variable i y para cada i ^-ésimo bit, verifique si el bit está configurado o no . Si se determina que es cierto, actualice cntSteps += 1
• Finalmente, imprima el valor de cntSteps .

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

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find minimum count of steps
// required to remove all the array elements
int minimumStepReqArr(int arr[], int N)
{
 
    // Stores minimum count of steps required
    // to remove all the array elements
    int cntStep = 0;
 
    // Update N
    N += 1;
 
    // Traverse each bit of N
    for (int i = 31; i >= 0; i--) {
 
        // If current bit is set
        if (N & (1 << i)) {
 
            // Update cntStep
            cntStep += 1;
        }
    }
 
    return cntStep;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << minimumStepReqArr(arr, N);
 
    return 0;
}

// Java program to implement
// the above approach
import java.util.*;
class GFG
{
 
  // Function to find minimum count of steps
  // required to remove all the array elements
  static int minimumStepReqArr(int[] arr, int N)
  {
 
    // Stores minimum count of steps required
    // to remove all the array elements
    int cntStep = 0;
 
    // Update N
    N += 1;
 
    // Traverse each bit of N
    for (int i = 31; i >= 0; i--)
    {
 
      // If current bit is set
      if ((N & (1 << i)) != 0)
      {
 
        // Update cntStep
        cntStep += 1;
      }
    }      
    return cntStep;
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int[] arr = { 1, 2, 3 };
 
    int N = arr.length;
    System.out.println(minimumStepReqArr(arr, N));
  }
}
 
// This code is contributed by susmitakundugoaldanga

# Python3 program to implement
# the above approach
 
# Function to find minimum count of steps
# required to remove all the array elements
def minimumStepReqArr(arr, N):
     
    # Stores minimum count of steps required
    # to remove all the array elements
    cntStep = 0
 
    # Update N
    N += 1
 
    i = 31
 
    while(i >= 0):
         
        # If current bit is set
        if (N & (1 << i)):
 
            # Update cntStep
            cntStep += 1
             
        i -= 1
 
    return cntStep
 
# Driver Code
if __name__ == '__main__':
     
    arr = [ 1, 2, 3 ]
    N = len(arr)
     
    print(minimumStepReqArr(arr, N))
 
# This code is contributed by SURENDRA_GANGWAR

// C# program to implement
// the above approach
using System;
class GFG
{
 
  // Function to find minimum count of steps
  // required to remove all the array elements
  static int minimumStepReqArr(int[] arr, int N)
  {
 
    // Stores minimum count of steps required
    // to remove all the array elements
    int cntStep = 0;
 
    // Update N
    N += 1;
 
    // Traverse each bit of N
    for (int i = 31; i >= 0; i--)
    {
 
      // If current bit is set
      if ((N & (1 << i)) != 0)
      {
 
        // Update cntStep
        cntStep += 1;
      }
    }      
    return cntStep;
  }
 
  // Driver code
  static void Main()
  {
    int[] arr = { 1, 2, 3 };
 
    int N = arr.Length;
    Console.WriteLine(minimumStepReqArr(arr, N));
  }
}
 
// This code is contributed by divyesh072019

<script>
    // Javascript program to implement the above approach
     
    // Function to find minimum count of steps
    // required to remove all the array elements
    function minimumStepReqArr(arr, N)
    {
 
      // Stores minimum count of steps required
      // to remove all the array elements
      let cntStep = 0;
 
      // Update N
      N += 1;
 
      // Traverse each bit of N
      for (let i = 31; i >= 0; i--)
      {
 
        // If current bit is set
        if ((N & (1 << i)) != 0)
        {
 
          // Update cntStep
          cntStep += 1;
        }
      }     
      return cntStep;
    }
     
    let arr = [ 1, 2, 3 ];
  
    let N = arr.length;
    document.write(minimumStepReqArr(arr, N));
 
// This code is contributed by suresh07.
</script>

1

Tiempo Complejidad: O(31)
Espacio Auxiliar: O(1)