0Pricing
DSA Interview Prep · Lektion

Burst Balloons: Umgekehrte Intervall-DP

Lösen Sie das Problem burst-balloons rückwärts: Wählen Sie in jedem Intervall den Ballon, der zuletzt platzt, statt den zuerst platzenden.

Burst Balloons: Umgekehrte Intervall-DP ist eine kostenlose DSA Interview Prep-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des DSA Interview Prep-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DSA Interview Prep-Kurs umfasst insgesamt 4 Lektionen.

Das Problem Burst Balloons

Gegeben seien n Ballons mit den Werten nums. Wenn Ballon i zerplatzt, erhalten Sie nums[i-1] * nums[i] * nums[i+1] Münzen, also das Produkt aus seinem eigenen Wert und den Werten seiner aktuellen Nachbarn. Nach dem Zerplatzen werden die Nachbarn benachbart. Finden Sie die maximale Anzahl an Münzen, die Sie durch das Zerplatzen aller Ballons sammeln können. Eine naive Simulation ist schwierig, da sich beim Zerplatzen die Nachbarn ändern – umgekehrte Intervall-DP umgeht diese Schwierigkeit elegant.

Warum die Vorwärtssimulation scheitert

Wenn wir dp[i][j] als maximale Münzanzahl beim Zerplatzen der Ballons im Bereich [i, j] definieren und überlegen, welchen Ballon wir zuerst zerplatzen lassen, entsteht ein Problem: Wenn Ballon k zuerst zerplatzt, müssen nums[k-1] und nums[k+1] seine aktuellen Nachbarn sein – diese Ballons könnten jedoch später zerplatzen, wodurch sich die Nachbarn dynamisch ändern. Der Zustand lässt sich in Vorwärtsrichtung nur schwer sauber definieren.

Die entscheidende Erkenntnis: Denken Sie rückwärts

Der Trick besteht darin, zu überlegen, welcher Ballon im Intervall [i, j] als Letzter zerplatzt. Wenn Ballon k im Intervall [i, j] als Letzter zerplatzt, sind alle anderen Ballons in [i, j] bereits verschwunden. Die Nachbarn von Ballon k sind dann genau nums[i-1] und nums[j+1] – die Randballons direkt außerhalb des Intervalls. Dadurch ist die Münzberechnung für den letzten Zerplatzvorgang deterministisch: Sie hängt nicht von der Reihenfolge der vorherigen Zerplatzvorgänge ab.

Definition von Zustand und Rekurrenz

Fügen Sie Sentinel-Ballons hinzu: Stellen Sie nums = [1] + nums + [1] her, indem Sie an nums vorne und hinten eine 1 anfügen. Definieren Sie dp[i][j] als die maximale Münzanzahl, die Sie erhalten, wenn Sie alle Ballons strikt zwischen den Indizes i und j zerplatzen lassen (exklusiv), wobei nums[i] und nums[j] die verbleibenden Randballons sind. Rekurrenz: Für jeden möglichen letzten Ballon k in (i, j) gilt: dp[i][j] = max(dp[i][k] + dp[k][j] + nums[i]*nums[k]*nums[j]).

# With sentinels: nums = [1] + original + [1]
# dp[i][j] = max coins from bursting all balloons in open interval (i, j)
# k = last balloon to burst in (i,j)
# dp[i][j] = max over k in (i,j): dp[i][k] + dp[k][j] + nums[i]*nums[k]*nums[j]

Vollständige Implementierung

Wir erweitern das Array um Sentinel-Werte, initialisieren die DP-Tabelle mit Nullen (leeres Intervall = 0 Münzen) und füllen sie für Intervalle mit zunehmender Länge. Die endgültige Antwort ist dp[0][n+1] und stellt die maximale Münzanzahl dar, die sich durch das Zerplatzen aller ursprünglichen Ballons mit den Sentinels als unveränderlichen Grenzen erzielen lässt.

def maxCoins(nums):
    nums = [1] + nums + [1]
    n = len(nums)
    dp = [[0]*n for _ in range(n)]
    
    # length of open interval (i, j) exclusive: j - i - 1 balloons inside
    for length in range(2, n):       # length = j - i
        for i in range(0, n - length):
            j = i + length
            for k in range(i+1, j):  # k is last burst in (i, j)
                coins = dp[i][k] + dp[k][j] + nums[i]*nums[k]*nums[j]
                dp[i][j] = max(dp[i][j], coins)
    
    return dp[0][n-1]

print(maxCoins([3, 1, 5, 8]))  # 167

Das Beispiel Schritt für Schritt

Für [3, 1, 5, 8], erweitert zu [1, 3, 1, 5, 8, 1] (Indizes 0–5). Gesucht ist dp[0][5]. Für Intervalle mit length=2 (ein Ballon im Inneren) gilt: dp[0][2] = 1*3*1=3, dp[1][3]=3*1*5=15, dp[2][4]=1*5*8=40, dp[3][5]=5*8*1=40. Durch schrittweises Aufbauen ergibt sich als Optimum, die 1 aus {3,1,5,8} zuletzt zerplatzen zu lassen, nachdem die Nachbarn zuerst zerplatzt wurden; dadurch erhält man insgesamt 167 Münzen.

Komplexitätsanalyse

Es gibt O(n²) Intervalle, und für jedes Intervall probieren wir O(n) Teilungspunkte aus. Daraus ergibt sich eine Zeitkomplexität von O(n³). Der Speicherbedarf für die DP-Tabelle beträgt O(n²). Für n = 500 Ballons sind das 125 Millionen Operationen – für typische Interview-Grenzen machbar. Das Auffüllen mit Sentinels vereinfacht die Behandlung der Randfälle: Ohne sie müssten Sie explizit prüfen, ob i-1 und j+1 innerhalb der Grenzen liegen.

Memoisierte Top-down-Alternative

Dieselbe Lösung kann mit @lru_cache als Top-down-Ansatz geschrieben werden, was sich während eines Interviews möglicherweise intuitiver herleiten lässt. Definieren Sie solve(i, j) als die maximale Münzanzahl im offenen Intervall (i, j). Die Funktion probiert alle k als letzten Zerplatzvorgang aus und memoisiert die Ergebnisse. Beide Ansätze haben dieselbe Zeit- und Speicherkomplexität.

from functools import lru_cache

def maxCoins_memo(nums):
    nums = [1] + nums + [1]
    n = len(nums)
    
    @lru_cache(maxsize=None)
    def solve(i, j):
        if j - i < 2:  # no balloons between i and j
            return 0
        return max(
            solve(i, k) + solve(k, j) + nums[i]*nums[k]*nums[j]
            for k in range(i+1, j)
        )
    
    return solve(0, n-1)

print(maxCoins_memo([3, 1, 5, 8]))  # 167

Häufiger Fehler: Vorwärtsdefinition der DP

Ein häufiger Fehler besteht darin, dp[i][j] als Münzanzahl zu definieren, wenn der erste Ballon in [i,j] zerplatzt, statt den letzten zu betrachten. Dies scheitert, weil die Münzberechnung für den ersten Zerplatzvorgang von Nachbarballons abhängt, die noch nicht zerplatzt sind – und sich der Zustand dieser Nachbarn im Verlauf des Algorithmus ändert. Denken Sie bei Intervall-DP immer an das letzte Element, wenn die Grenzen von den verbleibenden Elementen abhängen.

Warum haben die Sentinel-Werte den Wert 1?

Sentinels mit dem Wert 1 werden gewählt, weil sie als neutrale Elemente für die Multiplikation fungieren. Wenn ein Randballon als Letzter zerplatzt, beträgt sein Münzwert boundary * last * boundary = 1 * last * 1 = last. Der Wert 0 würde 0 Münzen ergeben (falsch), andere Werte würden die Berechnung verfälschen. Der Sentinel-Trick vereinheitlicht alle Randfälle, ohne den Ballon ganz links und den ganz rechts gesondert behandeln zu müssen.

Abgrenzung zur standardmäßigen Intervall-DP

Bei standardmäßiger Intervall-DP (Matrix Chain) bezeichnet der Teilungspunkt k die Stelle, an der wir das Problem in zwei unabhängig gelöste Teilprobleme aufteilen. Bei Burst Balloons ist k der Ballon, der im Intervall als Letzter zerplatzt. Dadurch sind die beiden Teilintervalle [i,k] und [k,j] unabhängig, solange k noch als Grenze vorhanden ist. Diese umgekehrte Perspektive ist die entscheidende kreative Erkenntnis, die es ermöglicht, Burst Balloons mit Intervall-DP zu lösen.

Kurzer Test

Testen Sie Ihr Verständnis der Konzepte aus Data Structures & Algorithms — Coding Interview Prep in dieser Lektion.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: Die Vorwärtssimulation scheitert, weil das Platzen von Ballons die Nachbarn unvorhersehbar verändert, die umgekehrte Erkenntnis definiert k als den zuletzt platzenden Ballon in einem Intervall, wodurch nums[i] und nums[j] zu Nachbarn werden, und die Rekurrenz dp[i][j] = max(dp[i][k] + dp[k][j] + nums[i]*nums[k]*nums[j]) mit Sentinel-Auffüllung ermöglicht eine Lösung in O(n³). Als Nächstes wechseln wir zur Rucksack-DP, beginnend mit dem klassischen 0/1-Rucksackproblem und seiner Speicheroptimierung.

Häufig gestellte Fragen

Ist die Lektion „Burst Balloons: Umgekehrte Intervall-DP“ kostenlos?

Ja — der vollständige Text von „Burst Balloons: Umgekehrte Intervall-DP“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DSA Interview Prep-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DSA Interview Prep-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Burst Balloons: Umgekehrte Intervall-DP“?

Lösen Sie das Problem burst-balloons rückwärts: Wählen Sie in jedem Intervall den Ballon, der zuletzt platzt, statt den zuerst platzenden. Du übst DSA Interview Prep mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um DSA Interview Prep zu starten?

Keine Vorkenntnisse erforderlich. DSA Interview Prep auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Burst Balloons: Umgekehrte Intervall-DP“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser DSA Interview Prep-Lektion Code schreiben und ausführen?

Ja. Jede DSA Interview Prep-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Intervall-DP-Muster und Reihenfolge des Ausfüllens
  2. Längste palindromische Teilfolge und Teilzeichenkette
  3. Palindrome Partitioning II
  4. Burst Balloons: Umgekehrte Intervall-DP
← Zurück zu DSA Interview Prep