Zum Hauptinhalt springen

1.2.6 Master-Theorem

Divide-and-Conquer​

Viele effiziente Algorithmen folgen dem Schema „Teile und herrsche“. Bei Eingabegröße nn:

  1. Teilen: Das Problem wird in aa Teilprobleme der Größe n/bn/b zerlegt.
  2. Rekursion: Jedes Teilproblem wird rekursiv gelöst, Kosten je T(n/b)T(n/b).
  3. Herrschen: Das Erzeugen der Teilprobleme und das Zusammenführen der Teillösungen kosten zusammen f(n)f(n).

Das ergibt die Rekursionsgleichung

T(n)=a⋅T(n/b)+f(n).T(n) = a\cdot T(n/b) + f(n).

Was ist die Gesamtlaufzeit? Für viele Fälle beantwortet das das Master-Theorem.

Satz (Master-Theorem für Rekursionen)​

Sei T(n)=a⋅T(n/b)+f(n)T(n) = a\cdot T(n/b)+f(n) mit

  • Konstanten a≥1a\ge1 und b>1b>1,
  • der Wasserscheiden-Konstante α:=log⁡ba\alpha := \log_b a,
  • einer Funktion f(n)f(n) (der Aufteilungsfunktion),
  • wobei n/bn/b als ⌊n/b⌋\lfloor n/b\rfloor oder ⌈n/b⌉\lceil n/b\rceil gelesen wird.

Dann gilt einer der folgenden Fälle:

FallBedingungErgebnis
1f(n)=O(nα−ε)f(n)=O(n^{\alpha-\varepsilon}) für ein ε>0\varepsilon>0T(n)=Θ(nα)T(n)=\Theta(n^\alpha)
2f(n)=Θ(nα)f(n)=\Theta(n^\alpha)T(n)=Θ(nαlog⁡n)T(n)=\Theta(n^\alpha\log n)
3f(n)=Ω(nα+ε)f(n)=\Omega(n^{\alpha+\varepsilon}) für ein ε>0\varepsilon>0 und a⋅f(n/b)≤c⋅f(n)a\cdot f(n/b)\le c\cdot f(n) für ein c<1c<1 und alle hinreichend großen nnT(n)=Θ(f(n))T(n)=\Theta(f(n))

Intuition​

Man stellt sich den Rekursionsbaum vor:

  • Ebene 0: ein Problem der Größe nn, Kosten f(n)f(n).
  • Ebene 1: aa Probleme der Größe n/bn/b, Kosten a f(n/b)a\,f(n/b).
  • Ebene ii: aia^i Probleme der Größe n/bin/b^i.
  • Der Baum hat Tiefe log⁡bn\log_b n und damit alog⁡bn=nlog⁡ba=nαa^{\log_b n} = n^{\log_b a} = n^\alpha Blätter.

nαn^\alpha ist also die Arbeit „in den Blättern“, f(n)f(n) die Arbeit „an der Wurzel“. Das Theorem vergleicht beide:

  • Fall 1 – Blätter dominieren: ff wächst polynomiell langsamer als nαn^\alpha. Die Arbeit steckt unten im Baum, also Θ(nα)\Theta(n^\alpha).
  • Fall 2 – Gleichstand: Jede der log⁡n\log n Ebenen kostet ungefähr gleich viel, nαn^\alpha. Insgesamt Θ(nαlog⁡n)\Theta(n^\alpha\log n).
  • Fall 3 – Wurzel dominiert: ff wächst polynomiell schneller. Die Kosten nehmen nach unten geometrisch ab (das garantiert die Regularitätsbedingung af(n/b)≤cf(n)af(n/b)\le cf(n)), die Wurzel bestimmt alles: Θ(f(n))\Theta(f(n)).

Zum Ausprobieren: Jeder Balken sind die Gesamtkosten einer Ebene des Rekursionsbaums. Wachsen sie nach unten (Fall 1), sind sie gleich (Fall 2) oder schrumpfen sie (Fall 3)?

Ebene 0: 1 × T(n/1)Ebene 1: 2 × T(n/2)Ebene 2: 4 × T(n/4)Ebene 3: 8 × T(n/8)Ebene 4: 16 × T(n/16)Ebene 5: 32 × T(n/32)Ebene 6: 64 × T(n/64)
T(n) = 2·T(n/2) + n, α = log2 2 = 1. Ebene i hat 2i Teilprobleme der Größe n/2i und kostet ∝ (2/21)i = 1i.
k = α ⇒ Fall 2: jede der log n Ebenen kostet gleich viel ⇒ T(n) = Θ(n · log n).
Lücken

Das Theorem deckt nicht alle Fälle ab. Liegt ff „zwischen“ den Fällen, z.B. f(n)=nαlog⁡nf(n)=n^\alpha\log n (größer als nαn^\alpha, aber nicht um einen Faktor nεn^\varepsilon), ist es in dieser Form nicht anwendbar.

Beispiele (Ergänzung)​

AlgorithmusRekursionα\alphaf(n)f(n) vs. nαn^\alphaFallErgebnis
Binäre SucheT(n)=T(n/2)+1T(n)=T(n/2)+1log⁡21=0\log_2 1=01=Θ(n0)1=\Theta(n^0)2Θ(log⁡n)\Theta(\log n)
MergesortT(n)=2T(n/2)+nT(n)=2T(n/2)+nlog⁡22=1\log_2 2=1n=Θ(n1)n=\Theta(n^1)2Θ(nlog⁡n)\Theta(n\log n)
Divide-and-Conquer-HülleT(n)=2T(n/2)+nT(n)=2T(n/2)+n11n=Θ(n)n=\Theta(n)2Θ(nlog⁡n)\Theta(n\log n)
KaratsubaT(n)=3T(n/2)+nT(n)=3T(n/2)+nlog⁡23≈1,58\log_2 3\approx1{,}58n=O(n1,58−ε)n=O(n^{1{,}58-\varepsilon})1Θ(n1,58)\Theta(n^{1{,}58})
–T(n)=2T(n/2)+n2T(n)=2T(n/2)+n^211n2=Ω(n1+ε)n^2=\Omega(n^{1+\varepsilon}), Regularität: 2(n/2)2=12n22(n/2)^2=\tfrac12n^2 ✔3Θ(n2)\Theta(n^2)

Bezug zu Kapitel 2: Die Divide-and-Conquer-Hülle teilt die Punkte an der Median-xx-Koordinate in zwei Hälften, berechnet beide Hüllen rekursiv und verschmilzt sie in O(n)O(n) über obere und untere Tangente. Nach Fall 2 ergibt das Θ(nlog⁡n)\Theta(n\log n), also dieselbe Laufzeit wie Graham's Scan.