Programme C++ pour supprimer le plus petit élément des deux côtés afin que la valeur minimale 2* soit supérieure à la valeur maximale

Le problème consiste à supprimer des éléments de chaque côté d'une liste d'entiers de telle manière que 2*min soit supérieur à max .

vector<int> arr = {250, 10, 11, 12, 19, 200};
res = solve(arr);

Nous pouvons utiliser des méthodes de force brute. Nous pouvons essayer toutes les satisfactions possibles et trouver le sous-tableau le plus long qui satisfait à la condition 2*min > max. Nous pouvons également utiliser des méthodes de programmation dynamique pour essayer toutes les combinaisons possibles de sous-tableaux excessifs et indésirables.

Exemple (en utilisant le vecteur ADT)

Supposons que nous ayons un tableau tel que "[250, 10, 11, 12, 19, 200]". Pour obtenir la meilleure solution, nous devons supprimer les éléments [250, 200] pour former un tableau [10, 11, 12, 19] où min est 10 et max est 19. Donc 2*10 > 19. Nous imprimons à partir d'un tableau, donc la sortie est 2.

Vous trouverez ci-dessous un programme C++ qui décrit comment supprimer un nombre minimum d'éléments d'un tableau tel que deux fois la valeur minimale soit supérieure à la valeur maximale -

#include <iostream>
#include <vector>
using namespace std;
int solve(vector<int> arr) {
   int startIndex = 0, endIndex = 0;
   bool foundAnAnswer = false;
   for (int start=0; start<arr.size(); start++) {
      int min = INT32_MAX, max = INT32_MIN;
      for (int end=start; end<arr.size(); end++) {
         if (arr[end] < min) min = arr[end];
         if (arr[end] > max) max = arr[end];
         if (2*min <= max) break;
         if (end - start > endIndex - startIndex || !foundAnAnswer) {
            startIndex = start;
            endIndex = end;
            foundAnAnswer = true;
         }
      }
   }
   if (!foundAnAnswer) return arr.size();
   return (arr.size() - (endIndex - startIndex + 1));
}
int main() {
   vector<int> arr = {250, 10, 11, 12, 19, 200};
   cout << solve(arr);
   return 0;
}

Sortie

2

Exemple (n'utilisant pas le vecteur ADT)

Voici un programme C++ décrivant comment supprimer un nombre minimum d'éléments d'un tableau tel que deux fois la valeur minimale soit supérieure à la valeur maximale, mais sans utiliser Vector ADT -

#include <iostream>
using namespace std;
int min(int a, int b) {return (a < b)? a : b;}
int min(int arr[], int low, int high)
   {
      int minimum = arr[low];
      for (int i=low+1; i<=high; i++)
      if (minimum > arr[i])
         minimum = arr[i];
      return minimum;
   }
int max(int arr[], int low, int high)
   {
      int maximum = arr[low];
      for (int i=low+1; i<=high; i++)
      if (maximum < arr[i])
         maximum = arr[i];
      return maximum;
   }
int minimum_removals(int arr[], int low, int high)
   {
      if (low >= high)
      return 0;
      int m1 = min(arr, low, high);
      int m2 = max(arr, low, high);
      if (2*m1 > m2)
      return 0;
      return min(minimum_removals(arr, low+1, high), minimum_removals(arr, low, high-1)) + 1;
   }
int main()
   {
      int arr[] = {12, 45, 32, 88, 100};
      int n = sizeof(arr)/sizeof(arr[0]);
      cout << minimum_removals(arr, 0, n-1);
      return 0;
   }

Sortie

3

Conclusion

Ici, nous utilisons la méthode de la force brute pour trouver le sous-tableau le plus long. D'autres solutions possibles pourraient inclure la vérification de tous les sous-tableaux possibles en faisant apparaître à plusieurs reprises des éléments des deux côtés et d'autres méthodes. Néanmoins, leur mise en œuvre demande beaucoup de travail et est moins optimisée. La complexité temporelle ici est O(n^2) car nous avons déjà parcouru tous les sous-tableaux.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!