Écrit en C++, traduisez ce qui suit en chinois : Calculez la somme commune minimale des K tableaux après avoir supprimé une partie du tableau

Lors de l'utilisation de tableaux C++, nous devons parfois calculer la somme commune minimale entre plusieurs tableaux tout en supprimant une partie de leurs suffixes. Dans cet article, nous explorerons une solution efficace à ce problème en utilisant C++.

Grammaire

Analysons d'abord la syntaxe de la méthode choisie avant de procéder à son implémentation dans notre code -

int findMinimumCommonSum(vector<vector<int>>& arrays, int suffixToRemove);

Algorithme

Voici un algorithme étape par étape pour résoudre le problème de trouver la somme la plus petite commune après avoir supprimé une partie du suffixe du tableau -

• Commencez par définir la fonction findMinimumCommonSum, qui accepte deux paramètres : des tableaux, un vecteur bidimensionnel représentant le tableau, et suffixToRemove, un entier représentant le nombre d'éléments à supprimer du suffixe de chaque tableau.

• Initialisez une variable minimumSum pour stocker la somme commune minimale et définissez sa valeur initiale sur une valeur plus grande.

• Parcourez chaque tableau du vecteur de tableau.

• Déterminez la taille du tableau actuel.

• Pour éviter de vous retrouver avec un tableau vide, pensez à ignorer les itérations suffixToRemove qui dépassent ou égalent la taille totale du tableau actuel. Dans ce cas, la suppression de tous les caractères ne produit aucun résultat significatif.

• Calculez la somme des éléments du tableau de l'index 0 à la taille - suffixToRemove - 1 et stockez-la dans la variable currentSum.

• Si currentSum est inférieur à minimumSum, mettez à jour minimumSum en utilisant la valeur de currentSum.

• Après avoir parcouru tous les tableaux, minimumSum contiendra la somme commune minimale dans les tableaux après avoir supprimé le suffixe spécifié.

Méthode 1 : Fissuration par force brute

Dans cette méthode, nous générerons toutes les combinaisons possibles des suffixes à supprimer et calculerons la somme pour chaque combinaison. La plus petite somme parmi toutes les combinaisons est la somme la moins commune.

Exemple

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

int findMinimumCommonSum(vector<vector<int>>& arrays, int suffixToRemove) {
   int minimumSum = INT_MAX;
   int k = arrays.size();

   for (int i = 0; i < k; i++) {
      int size = arrays[i].size();

      if (suffixToRemove >= size)
         continue;

      vector<bool> suffix(size, false);
      fill(suffix.begin() + size - suffixToRemove, suffix.end(), true);

      do {
         int currentSum = 0;
         
         for (int j = 0; j < k; j++) {
            int arraySum = 0;
            for (int l = 0; l < size; l++) {
               if (!suffix[l])
                  arraySum += arrays[j][l];
            }
            currentSum += arraySum;
         }

         if (currentSum < minimumSum)
            minimumSum = currentSum;

      } while (next_permutation(suffix.begin(), suffix.end()));
   }

   return minimumSum;
}

int main() {
   vector<vector<int>> arrays = {{1, 2, 3},
                                 {4, 5, 6},
                                 {7, 8, 9}};

   int suffixToRemove = 1;

   int minimumCommonSum = findMinimumCommonSum(arrays, suffixToRemove);

   cout << "Minimum Common Sum: " << minimumCommonSum << endl;

   return 0;
}

Sortie

Minimum Common Sum: 27

Instructions

Dans la méthode de la force brute, notre objectif est de trouver la somme commune minimale entre plusieurs tableaux après avoir supprimé un nombre spécifié d'éléments de leurs suffixes. Le procédé consiste à générer toutes les combinaisons possibles des suffixes à supprimer et à calculer la somme de chaque combinaison. La plus petite somme parmi toutes les combinaisons sera la plus petite somme commune.

Pour implémenter cette approche, nous définissons une fonction appelée findMinimumCommonSum, qui accepte deux paramètres : array (un vecteur 2D représentant le tableau) et suffixToRemove (un entier représentant le nombre d'éléments à supprimer de chaque suffixe du tableau).

À l'intérieur de la fonction, nous initialisons une variable minimumSum pour stocker la somme commune minimale, et la valeur initiale est définie sur la valeur maximale possible de type int. Ensuite, nous parcourons chaque tableau du vecteur tableau. Pour chaque tableau, nous déterminons sa taille et vérifions si la valeur suffixToRemove est inférieure à la taille.

Si les conditions sont remplies, nous utilisons un vecteur booléen pour générer toutes les combinaisons de suffixes possibles. Nous remplissons les derniers éléments suffixToRemove avec true et les éléments restants avec false. Pour chaque tableau, nous déterminons sa taille et vérifions si la valeur suffixToRemove est inférieure à la taille.

Nous procédons en calculant la somme des valeurs du tableau correspondant aux faux indicateurs dans le vecteur suffixe, pour chaque combinaison. Nous répétons ce processus pour tous les tableaux, en mettant à jour currentSum en conséquence.

Enfin, nous comparons currentSum avec minimumSum et mettons à jour minimumSum si currentSum est plus petit. Après avoir parcouru tous les tableaux et combinaisons, minimumSum contiendra la somme commune minimale après avoir supprimé le suffixe spécifié.

Méthode 2 : Tri efficace

Dans cette méthode, nous trierons les tableaux dans un ordre non décroissant et calculerons la somme des éléments de première taille - suffixToRemove de chaque tableau. La plus petite somme parmi tous les tableaux sera la plus petite somme commune.

Exemple

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

int findMinimumCommonSum(vector<vector<int>>& arrays, int suffixToRemove) {
   int minimumSum = INT_MAX;
   int k = arrays.size();

   for (int i = 0; i < k; i++) {
      int size = arrays[i].size();

      if (suffixToRemove >= size)
         continue;

      sort(arrays[i].begin(), arrays[i].end());

      int currentSum = 0;
      for (int j = 0; j < size - suffixToRemove; j++)
         currentSum += arrays[i][j];

      if (currentSum < minimumSum)
         minimumSum = currentSum;
   }

   return minimumSum;
}

int main() {
   vector<vector<int>> arrays = {{1, 2, 3},
                                 {4, 5, 6},
                                 {7, 8, 9}};

   int suffixToRemove = 1;

   int minimumCommonSum = findMinimumCommonSum(arrays, suffixToRemove);

   cout << "Minimum Common Sum: " << minimumCommonSum << endl;
   
   return 0;
}

Sortie

Minimum Common Sum: 3

Instructions

Dans une méthode de tri efficace, notre objectif est de trouver la somme commune minimale entre plusieurs tableaux après avoir supprimé le nombre spécifié d'éléments du suffixe. Cette méthode profite du fait que le tri du tableau simplifie le calcul de la somme minimale.

Pour implémenter cette approche, nous définissons une fonction appelée findMinimumCommonSum, qui accepte deux paramètres : array (un vecteur 2D représentant le tableau) et suffixToRemove (un entier représentant le nombre d'éléments à supprimer de chaque suffixe du tableau).

À l'intérieur de la fonction, nous initialisons une variable minimumSum pour stocker la somme commune minimale, et la valeur initiale est définie sur la valeur maximale possible de type int. Ensuite, nous parcourons chaque tableau du vecteur tableau. Pour chaque tableau, nous déterminons sa taille et vérifions si la valeur suffixToRemove est inférieure à la taille.

Lorsque cette condition préalable est remplie, l'une de nos prochaines étapes consistera à trier tous les composants individuels de notre tableau par ordre croissant ; cette approche permet principalement de garantir que les objets plus petits se trouvent dans leur section initiale pour améliorer la disposition et la lisibilité.

Ensuite, nous calculons la somme des premiers éléments size - suffixToRemove dans le tableau trié. Cela correspond à supprimer le nombre d’éléments spécifié du suffixe. Nous mettons à jour currentSum en conséquence.

Enfin, nous comparons currentSum avec minimumSum et mettons à jour minimumSum si currentSum est plus petit. Après avoir parcouru tous les tableaux, minimumSum contiendra la somme commune minimale après avoir supprimé le suffixe spécifié.

Cette méthode est très efficace car elle ne nécessite pas de générer et d'itérer toutes les combinaisons possibles comme les méthodes par force brute. Au lieu de cela, il exploite les propriétés de commande pour simplifier le calcul de la somme minimale, améliorant ainsi les performances.

Conclusion

Dans cet article, nous explorons un moyen efficace de trouver la somme commune minimale parmi les K tableaux en C++ après avoir supprimé une partie de leur suffixe. Nous avons discuté de deux méthodes : la force brute et le tri efficace. La méthode par force brute consiste à générer toutes les combinaisons de suffixes, tandis que la méthode de tri efficace trie le tableau et calcule la somme des premiers éléments. En fonction de la taille du tableau et du nombre d'éléments de suffixe à supprimer, un tri efficace est généralement plus efficace. En implémentant ces méthodes dans un programme C++, vous pouvez facilement trouver la plus petite somme commune à partir de plusieurs tableaux et gérer efficacement la suppression des suffixes.

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!