Design - Fallstudien

1
Design - Fallstudien

• Christian Mansky
• mansky_at_wist.uni-linz.ac.at

2
Übersicht
Das erste Problem und ein einfacher
Algorithmus erster Lösungsversuch mit
quadratischer Laufzeit mit linearer
Laufzeit Suche in Zeichenfolgen
Aufgabenbeschreibung Brute Force Der
Boyer-Moore Algorithmus (1) Der Boyer-Moore
Algorithmus (2) Der Binomialkoeffizient Die
Aufgabenstellung Ein rekursiver
Algorithmus Ein iterativer Algorithmus Ein
linearer iterativer Algorithmus
3
Das Problem und ein einfacher Algorithmus

• Gegeben ist ein Eingabevektor x mit n Elementen
  (vom Typ Float).
• Gesucht ist die maximale Summe die in einem
  zusammenhängenden Subvektor der Eingabe gefunden
  werden kann.

4
Ein erster Lösungsversuch

• maxsofar 0
• for i 0,n)
• for j i,n)
• sum 0
• for k i,j sum xk
• / sum is sum of xi..j /
• maxsofar max (maxsofar, sum)
• Der Algorithmus hat kubische Laufzeit.
• Messungen auf meinem Computer
• Bei n 10.000 beträgt die Laufzeit ca. 14,5
  Minuten.
• Bei n 100.000 beträgt die Laufzeit schon ca. 10
  Tage.

5
Ein Algorithmus mit quadratischer Laufzeit

• maxsofar 0
• for i 0,n)
• sum 0
• for j i,n)
• sum xj
• / sum is sum of xi..j /
• maxsofar max (maxsofar, sum)
• Der Algorithmus hat quadratische Laufzeit.
• Das bedeutet bei n 10.000 läuft der Algorithmus
  797 ms.
• Bei n 100.000 hat der Algorithmus eine Laufzeit
  von ca. 1,3 Minuten.

6
Ein Algorithmus mit linearer Laufzeit

• maxsofar 0 maxendinghere 0
• for i 0,n)
• maxendinghere max (maxendingherexi, 0)
• maxsofar max (maxsofar, maxendinghere)
• Angenommen das Problem ist für x0..i-1 gelöst
• Das maximale Subarray in den ersten i Elementen
  befindet sich entweder in den ersten i-1Elementen
  (gespeichert in maxsofar), oder oder es endet auf
  Position i (gespeichert in maxendinghere)
• Die Laufzeit bei n 1.000.000 Elementen beträgt
  32 ms!

7
Suche in Zeichenfolgen Aufgabenbeschreibung

• Gegeben
• String text A string consisting ...
• String pattern sting
• Gesucht
• int pos 15

8
Suche in Zeichenfolgen Brute Force

• i1 pos 0
• while (iltlength(text)-length(pattern)1)
  (pos0)
• j1
• while (jltlength(pattern)) (textij-1
  patternj)
• jj1
• end
• if (jgtlength(pattern)) posi end
• ii1
• end
• / Ergebnis in pos /
• Laufzeitkomplexität O(n2)

9
Suche in Zeichenfolgen Der Boyer-Moore
Algorithmus (1)
shifts length(pattern)-1 shiftt
length(pattern)-2 shifti length(pattern)-3 shi
ftn length(pattern)-4 shiftg
length(pattern)-5
10
Suche in Zeichenfolgen Der Boyer-Moore
Algorithmus (2)

• for i0,MAXCHAR shiftilength(pattern)
• for j1,length(pattern) shiftORD(patternj)
  length(pattern) - j
• i j length (pattern)
• repeat
• if textipatternj
• i-- j--
• else
• hshiftORD(texti)
• if (hgtlength(pattern)-j1) iih
• else iilength(Pattern)-j1
• j m
• until (j0) (igtlength(text))
• If (j0) posi1 else pos-1
• return pos

11
Der Binomialkoeffizient Die Aufgabenstellung
12
Der Binomialkoeffizient Ein rekursiver Algorithms

• binCoeff (int n, int k)
• if (k0 kn) return 1
• else return binCoeff (n-1,k-1) binCoeff
  (n-1, k)
• Einfacher Algorithmus
• - Ergebnisse die bereits berechnet wurden, werden
  nochmals berechnet
• - Sehr Laufzeitkomplex O(2n/n)

13
Der Binomialkoeffizient Ein iterativer Algorithms

• /Invariante bcn1k1 wird mit 0
  initialisiert/
• for i0, n bci0 1 bci1 i
• for i1,n
• for j2,k
• bc ij bci-1j-1bci-1j
• /Ergebnis in bcnk/
• Die Zeitkomplexität beträgt O(nk)

14
Der Binomialkoeffizient Ein linearer iterativer
Algorithms

• nenner zaehler1 zaehler2 0
• for i1,n nenner i
• for j1,k zaehler1 j
• for h1,n-k zaheler2 h
• bc i/(zahler1zahler2)
• Verzicht auf Rekursion, wenn eine offensichtliche
  iterative Lösung existiert.
• Umgehe aber Rekursion nicht um jeden Preis!
• Probleme die ihrem Wesen nach eher rekursiv sind,
  können auch rekursiv implementiert werden.

15
Danke für die Aufmerksamkeit!