Übersetzen Sie Folgendes in C++ geschrieben ins Chinesische: Berechnen Sie die minimale gemeinsame Summe von K Arrays, nachdem Sie einen Teil des Arrays gelöscht haben

Bei der Verwendung von C++-Arrays müssen wir manchmal die minimale gemeinsame Summe mehrerer Arrays berechnen und gleichzeitig einen Teil ihrer Suffixe entfernen. In diesem Artikel werden wir eine effiziente Lösung für dieses Problem mit C++ untersuchen.

Grammatik

Lassen Sie uns zunächst die Syntax der von uns gewählten Methode analysieren, bevor wir mit der Implementierung in unserem Code fortfahren -

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

Algorithmus

Hier ist ein Schritt-für-Schritt-Algorithmus zur Lösung des Problems, die kleinste gemeinsame Summe zu finden, nachdem ein Teil des Array-Suffixes gelöscht wurde -

• Beginnen Sie mit der Definition der Funktion findMinimumCommonSum, die zwei Parameter akzeptiert – Arrays, einen zweidimensionalen Vektor, der das Array darstellt, und suffixToRemove, eine Ganzzahl, die die Anzahl der Elemente darstellt, die aus dem Suffix jedes Arrays entfernt werden sollen.

• Initialisieren Sie eine Variable „MinimumSum“, um die minimale gemeinsame Summe zu speichern, und setzen Sie ihren Anfangswert auf einen größeren Wert.

• Iterieren Sie über jedes Array im Array-Vektor.

• Bestimmen Sie die Größe des aktuellen Arrays.

• Um zu vermeiden, dass am Ende ein leeres Array entsteht, sollten Sie erwägen, suffixToRemove-Iterationen zu überspringen, die die Gesamtgröße des aktuellen Arrays überschreiten oder dieser entsprechen. Das Entfernen aller Zeichen führt in diesem Fall zu keiner sinnvollen Ausgabe.

• Berechnen Sie die Summe der Array-Elemente von Index 0 bis Größe - suffixToRemove - 1 und speichern Sie sie in der Variablen currentSum.

• Wenn currentSum kleiner als MinimumSum ist, aktualisieren Sie MinimumSum mit dem Wert von currentSum.

• Nach dem Durchlaufen aller Arrays enthält MinimumSum die minimale gemeinsame Summe in den Arrays, nachdem das angegebene Suffix entfernt wurde.

Methode 1: Brute-Force-Cracking

Bei dieser Methode generieren wir alle möglichen Kombinationen der zu entfernenden Suffixe und berechnen die Summe für jede Kombination. Die kleinste Summe aller Kombinationen ist die am wenigsten gemeinsame Summe.

Beispiel

#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;
}

Ausgabe

Minimum Common Sum: 27

Anleitung

Bei der Brute-Force-Methode besteht unser Ziel darin, die minimale gemeinsame Summe zwischen mehreren Arrays zu ermitteln, nachdem eine bestimmte Anzahl von Elementen aus ihren Suffixen entfernt wurde. Die Methode besteht darin, alle möglichen Kombinationen der zu entfernenden Suffixe zu generieren und die Summe jeder Kombination zu berechnen. Die kleinste Summe aller Kombinationen ist die kleinste gemeinsame Summe.

Um diesen Ansatz zu implementieren, definieren wir eine Funktion namens findMinimumCommonSum, die zwei Parameter akzeptiert: array (ein 2D-Vektor, der das Array darstellt) und suffixToRemove (eine Ganzzahl, die die Anzahl der Elemente darstellt, die aus jedem Array-Suffix entfernt werden sollen).

Innerhalb der Funktion initialisieren wir eine Variable MinimumSum, um die minimale gemeinsame Summe zu speichern, und der Anfangswert wird auf den maximal möglichen Wert vom Typ int gesetzt. Dann durchlaufen wir jedes Array im Array-Vektor. Für jedes Array bestimmen wir seine Größe und prüfen, ob der suffixToRemove-Wert kleiner als die Größe ist.

Wenn die Bedingungen erfüllt sind, verwenden wir einen booleschen Vektor, um alle möglichen Suffixkombinationen zu generieren. Wir füllen die letzten suffixToRemove-Elemente mit true und die restlichen Elemente mit false. Für jedes Array bestimmen wir seine Größe und prüfen, ob der suffixToRemove-Wert kleiner als die Größe ist.

Wir fahren fort, indem wir für jede Kombination die Summe der Array-Werte berechnen, die den falschen Indikatoren im Suffix-Vektor entsprechen. Wir wiederholen diesen Vorgang für alle Arrays und aktualisieren currentSum entsprechend.

Abschließend vergleichen wir currentSum mit MinimumSum und aktualisieren MinimumSum, wenn currentSum kleiner ist. Nach dem Durchlaufen aller Arrays und Kombinationen enthält MinimumSum die minimale gemeinsame Summe, nachdem das angegebene Suffix entfernt wurde.

Methode 2: Effiziente Sortierung

Bei dieser Methode sortieren wir die Arrays in nicht absteigender Reihenfolge und berechnen die Summe der ersten Größen-SuffixToRemove-Elemente jedes Arrays. Die kleinste Summe aller Arrays ist die kleinste gemeinsame Summe.

Beispiel

#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;
}

Ausgabe

Minimum Common Sum: 3

Anleitung

Bei der effizienten Sortiermethode besteht unser Ziel darin, die minimale gemeinsame Summe zwischen mehreren Arrays zu ermitteln, nachdem die angegebene Anzahl von Elementen aus dem Suffix entfernt wurde. Diese Methode macht sich die Tatsache zunutze, dass das Sortieren des Arrays die Berechnung der Mindestsumme vereinfacht.

Um diesen Ansatz zu implementieren, definieren wir eine Funktion namens findMinimumCommonSum, die zwei Parameter akzeptiert: array (ein 2D-Vektor, der das Array darstellt) und suffixToRemove (eine Ganzzahl, die die Anzahl der Elemente darstellt, die aus jedem Array-Suffix entfernt werden sollen).

Innerhalb der Funktion initialisieren wir eine Variable MinimumSum, um die minimale gemeinsame Summe zu speichern, und der Anfangswert wird auf den maximal möglichen Wert vom Typ int gesetzt. Dann durchlaufen wir jedes Array im Array-Vektor. Für jedes Array bestimmen wir seine Größe und prüfen, ob der suffixToRemove-Wert kleiner als die Größe ist.

Wenn diese Voraussetzung erfüllt ist, besteht einer unserer nächsten Schritte darin, alle einzelnen Komponenten in unserem Array in aufsteigender Reihenfolge zu sortieren. Dieser Ansatz trägt hauptsächlich dazu bei, sicherzustellen, dass sich kleinere Objekte in ihrem Anfangsabschnitt befinden, um die Anordnung und Lesbarkeit zu verbessern.

Als nächstes berechnen wir die Summe der ersten Größen-SuffixToRemove-Elemente im sortierten Array. Dies entspricht dem Entfernen der angegebenen Anzahl von Elementen aus dem Suffix. Wir aktualisieren currentSum entsprechend.

Abschließend vergleichen wir currentSum mit MinimumSum und aktualisieren MinimumSum, wenn currentSum kleiner ist. Nach dem Durchlaufen aller Arrays enthält MinimumSum die minimale gemeinsame Summe, nachdem das angegebene Suffix entfernt wurde.

Diese Methode ist sehr effizient, da sie nicht wie Brute-Force-Methoden die Generierung und Iteration aller möglichen Kombinationen erfordert. Stattdessen nutzt es die Ordnungseigenschaften, um die Berechnung der Mindestsumme zu vereinfachen und so die Leistung zu verbessern.

Fazit

In diesem Artikel untersuchen wir eine effiziente Möglichkeit, die minimale gemeinsame Summe zwischen K-Arrays in C++ zu ermitteln, nachdem wir einen Teil ihres Suffixes entfernt haben. Wir haben zwei Methoden besprochen – Brute Force und effiziente Sortierung. Bei der Brute-Force-Methode werden alle Kombinationen von Suffixen generiert, während bei der effizienten Sortiermethode das Array sortiert und die Summe der ersten paar Elemente berechnet wird. Abhängig von der Größe des Arrays und der Anzahl der zu entfernenden Suffixelemente ist eine effiziente Sortierung normalerweise effizienter. Durch die Implementierung dieser Methoden in einem C++-Programm können Sie problemlos die kleinste gemeinsame Summe aus mehreren Arrays ermitteln und das Entfernen von Suffixen effizient durchführen.

Das obige ist der detaillierte Inhalt vonÜbersetzen Sie Folgendes in C++ geschrieben ins Chinesische: Berechnen Sie die minimale gemeinsame Summe von K Arrays, nachdem Sie einen Teil des Arrays gelöscht haben. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!