Ordnen Sie ein Array so um, dass die Summe der Produkte aufeinanderfolgender Elementpaare minimal ist, geschrieben in C++

Wir haben ein Array positiver Ganzzahltypen, vorausgesetzt, es ist arr[], mit beliebiger Größe. Die Aufgabe besteht darin, das Array so umzuordnen, dass die kleinste Summe zurückgegeben wird, wenn wir ein Element mit seinen angrenzenden Elementen multiplizieren und dann alle resultierenden Elemente addieren.

Sehen wir uns verschiedene Eingabe- und Ausgabesituationen an:

Eingabe - int arr[] = {2, 5, 1, 7, 5, 0, 1, 0}

Ausgabe - Ordnen Sie das Array auf „Minimieren“ um die Summe, also das Produkt eines aufeinanderfolgenden Elementpaares, ist: 7 0 5 0 5 1 2 1

Erklärung- Wir haben ein ganzzahliges Array der Größe 8. Jetzt werden wir das Array neu anordnen, d. h. 7 0 5 0 5 1 2 1. Wir prüfen, ob die Mindestsumme zurückgegeben wird, d. h. 7 * 0 + 5 * 0 + 5 * 1 + 2 * 1 = 0 + 0 + 5 + 2 = 7.

Eingabe - int arr[] = {1, 3, 7, 2, 4, 3}

Ausgabe - Ordnen Sie das Array neu an, um die Summe zu minimieren, d. h. das Produkt eines aufeinanderfolgenden Elementpaars : 7 1 4 2 3 3

Erklärung- Wir haben ein Array von ganzen Zahlen der Größe 6. Jetzt werden wir das Array neu anordnen, d. h. 7 1 4 2 3 3. Wir prüfen, ob die Mindestsumme zurückgegeben wird, die 7 * 1 + 4 * 2 + 3 * 3 = 7 + 8 + 9 = 24 beträgt.

Die im folgenden Programm verwendete Methode lautet wie folgt:

• Geben Sie ein Array vom Typ Integer ein und berechnen Sie die Größe des Arrays.

• Sortieren Sie das Array mit der Sortiermethode von C++ STL und übergeben Sie das Array und die Größe des Arrays an die Sortierfunktion.

• Deklarieren Sie eine Ganzzahlvariable und legen Sie sie als Rückgabewert der aufrufenden Funktion fest.

Rearrange_min_sum(arr, size)

Innerhalb der Funktion Rearrange_min_sum(arr, size)

• Erstellen Sie eine Variable, sagen wir, „gerade“ und „ungerade“ Typvektor, der ganzzahlige Variablen speichert.

• Deklarieren Sie eine Variable als temp und total und initialisieren Sie sie mit 0.

• Starten Sie die Schleife FOR von i bis 0, bis i kleiner als size ist. Überprüfen Sie innerhalb der Schleife, ob i kleiner als size/2 ist, und drücken Sie dann arr[i] auf ungerader Vektor ELSE, schiebe arr[i] auf geraden Vektor

• Rufen Sie die Sortiermethode auf, indem Sie even.begin(), even.end() und great() übergeben.

• Schleife FOR von i starten auf 0, bis i kleiner als even.size() ist. Setzen Sie innerhalb der Schleife arr[temp++] auf even[j], arr[temp++] auf odd[j] und total auf total + even[j] * odd[j].

• Gesamtsumme zurückgeben

Ergebnis drucken.

Beispiel

#include <bits/stdc++.h>
using namespace std;
int Rearrange_min_sum(int arr[], int size){
   vector<int> even, odd;
   int temp = 0;
   int total = 0;
   for(int i = 0; i < size; i++){
      if (i < size/2){
         odd.push_back(arr[i]);
      }
      else{
         even.push_back(arr[i]);
      }
   }
   sort(even.begin(), even.end(), greater<int>());
   for(int j = 0; j < even.size(); j++){
      arr[temp++] = even[j];
      arr[temp++] = odd[j];
      total += even[j] * odd[j];
   }
   return total;
}
int main(){
   int arr[] = { 2, 5, 1, 7, 5, 0, 1, 0};
   int size = sizeof(arr)/sizeof(arr[0]);
   //sort an array
   sort(arr, arr + size);
   //call function
   int total = Rearrange_min_sum(arr, size);
   cout<<"Rearrangement of an array to minimize sum i.e. "<<total<<" of product of consecutive pair elements is: ";
   for(int i = 0; i < size; i++){
      cout << arr[i] << " ";
   }
   return 0;
}

Ausgabe

Wenn wir den obigen Code ausführen, wird die folgende Ausgabe generiert:

Rearrangement of an array to minimize sum i.e. 7 of product of consecutive pair elements is: 7 0 5 0 5 1 2 1

Das obige ist der detaillierte Inhalt vonOrdnen Sie ein Array so um, dass die Summe der Produkte aufeinanderfolgender Elementpaare minimal ist, geschrieben in C++. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!