Suche…


Schneiden Sie die Stange, um den maximalen Gewinn zu erzielen

Angenommen, ein Stab der Länge n Zoll und ein Array der Länge m der Preise enthält die Preise aller Stücke mit einer Größe kleiner als n. Wir müssen den maximalen Wert finden, der durch das Schneiden der Stange und den Verkauf der Stücke erzielt werden kann. Wenn beispielsweise die Länge der Stange 8 beträgt und die Werte der verschiedenen Teile wie folgt angegeben werden, beträgt der maximal erreichbare Wert 22 .

       +---+---+---+---+---+---+---+---+
 (price)| 1 | 5 | 8 | 9 | 10| 17| 17| 20|
        +---+---+---+---+---+---+---+---+

Wir verwenden ein 2D-Array dp [m] [n + 1], wobei n die Länge des Stabes und m die Länge des Preisarrays ist. Für unser Beispiel benötigen wir dp [8] [9] . Hier bezeichnet dp [i] [j] den maximalen Preis, indem es den Stab der Länge j verkauft. Wir können den maximalen Wert der Länge j als Ganzes haben oder wir hätten die Länge gebrochen, um den Gewinn zu maximieren.

Zuerst wird für die 0-te Spalte nichts hinzugefügt, also werden alle Werte als 0 gekennzeichnet. Alle Werte der 0-ten Spalte sind 0. Für dp [0] [1] , was ist der maximale Wert, den wir erreichen können Der Verkauf der Rute der Länge 1. Es wird gleich 1. für die Rute der Länge 2 dp [0] [2] sein, wir können 2 (1 + 1) haben. Dies geht weiter bis dp [0] [8] . Nach der ersten Iteration unser dp [] -Array wird so aussehen.

      +---+---+---+---+---+---+---+---+---+
 (price)| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
        +---+---+---+---+---+---+---+---+---+
  (1) 1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 9 |
        +---+---+---+---+---+---+---+---+---+
  (5) 2 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
  (8) 3 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
  (9) 4 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
 (10) 5 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
 (17) 6 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
 (17) 7 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
 (20) 8 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+

Für dp [2] [2] müssen wir uns fragen, was ich am besten kann, wenn ich die Stange in zwei Teile zerbreche (1,1) oder die Stange als Ganzes nehme (Länge = 2). Wir können sehen Wenn ich die Stange in zwei Teile zerbreche, ist der maximale Gewinn, den ich erzielen kann, 2, und wenn ich die Stange als Ganzes habe, kann ich sie für 5 verkaufen. Nach dem zweiten Durchlauf sieht das dp [] -Array so aus:

     +---+---+---+---+---+---+---+---+---+
 (price)| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
        +---+---+---+---+---+---+---+---+---+
  (1) 1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 9 |
        +---+---+---+---+---+---+---+---+---+
  (5) 2 | 0 | 1 | 5 | 6 | 10| 11| 15| 16| 20|
        +---+---+---+---+---+---+---+---+---+
  (8) 3 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
  (9) 4 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
 (10) 5 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
 (17) 6 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
 (17) 7 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+
 (20) 8 | 0 |   |   |   |   |   |   |   |   |
        +---+---+---+---+---+---+---+---+---+ 

Um dp [i] [j] zu berechnen, wird unsere Formel folgendermaßen aussehen:

if j>=i
    dp[i][j] = Max(dp[i-1][j], price[i]+arr[i][j-i]);
else
    dp[i][j] = dp[i-1][j];

Nach der letzten Iteration wird unser dp [] -Array aussehen

       +---+---+---+---+---+---+---+---+---+
 (price)| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
        +---+---+---+---+---+---+---+---+---+
  (1) 1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 9 |
        +---+---+---+---+---+---+---+---+---+
  (5) 2 | 0 | 1 | 5 | 6 | 10| 11| 15| 16| 20|
        +---+---+---+---+---+---+---+---+---+
  (8) 3 | 0 | 1 | 5 | 8 | 10| 13| 16| 18| 21|
        +---+---+---+---+---+---+---+---+---+
  (9) 4 | 0 | 1 | 5 | 8 | 10| 13| 16| 18| 21|
        +---+---+---+---+---+---+---+---+---+
 (10) 5 | 0 | 1 | 5 | 8 | 10| 13| 16| 18| 21|
        +---+---+---+---+---+---+---+---+---+
 (17) 6 | 0 | 1 | 5 | 8 | 10| 13| 17| 18| 22|
        +---+---+---+---+---+---+---+---+---+
 (17) 7 | 0 | 1 | 5 | 8 | 10| 13| 17| 18| 22|
        +---+---+---+---+---+---+---+---+---+
 (20) 8 | 0 | 1 | 5 | 8 | 10| 13| 17| 18| 22|
        +---+---+---+---+---+---+---+---+---+

Wir erhalten das Ergebnis bei dp [n] [m + 1] .

Implementierung in Java

public int getMaximumPrice(int price[],int n){
        int arr[][] = new int[n][price.length+1];
        
        for(int i=0;i<n;i++){
            for(int j=0;j<price.length+1;j++){
                if(j==0 || i==0)
                    arr[i][j] = 0;
                else if(j>=i){
                    arr[i][j] = Math.max(arr[i-1][j], price[i-1]+arr[i][j-i]);
                }else{
                    arr[i][j] = arr[i-1][j];
                }
            }
        }
        return arr[n-1][price.length];
    }

Zeitkomplexität

O(n^2)


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow