Präsentation herunterladen
Die Präsentation wird geladen. Bitte warten
1
Christian Mansky mansky@wist.uni-linz.ac.at
Design - Fallstudien Christian Mansky
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 += x[k] /* sum is sum of x[i..j] */ maxsofar = max (maxsofar, sum) Der Algorithmus hat kubische Laufzeit. Messungen auf meinem Computer: Bei n= beträgt die Laufzeit ca. 14,5 Minuten. Bei n= 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 += x[j] /* sum is sum of x[i..j] */ maxsofar = max (maxsofar, sum) Der Algorithmus hat quadratische Laufzeit. Das bedeutet bei n = läuft der Algorithmus 797 ms. Bei n = 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 (maxendinghere+x[i], 0); maxsofar = max (maxsofar, maxendinghere); Angenommen das Problem ist für x[0..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= 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
i=1; pos = 0; while (i<length(text)-length(pattern)+1) & (pos=0) j=1 while (j<=length(pattern)) & (text[i+j-1] = pattern[j]) j=j+1 end if (j>length(pattern)) pos=i end; i:=i+1 /* Ergebnis in pos */ Laufzeitkomplexität: O(n^2)
9
Suche in Zeichenfolgen: Der Boyer-Moore Algorithmus (1)
shift[s] = length(pattern)-1 shift[t] = length(pattern)-2 shift[i] = length(pattern)-3 shift[n] = length(pattern)-4 shift[g] = length(pattern)-5
10
Suche in Zeichenfolgen: Der Boyer-Moore Algorithmus (2)
for i=[0,MAXCHAR] shift[i]=length(pattern) for j=[1,length(pattern)] shift[ORD(pattern[j])]= length(pattern) - j i = j = length (pattern) repeat if text[i]=pattern[j] i--; j--; else h=shift[ORD(text[i])] if (h>=length(pattern)-j+1) i=i+h else i=i+length(Pattern)-j+1 j = m; until (j=0) | (i>length(text)) If (j=0) pos=i+1; else pos=-1; return pos;
11
Der Binomialkoeffizient: Die Aufgabenstellung
12
Der Binomialkoeffizient: Ein rekursiver Algorithms
binCoeff (int n, int k) { if (k==0 || k==n) 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(2^n/n)
13
Der Binomialkoeffizient: Ein iterativer Algorithms
/*Invariante: bc[n+1][k+1] wird mit 0 initialisiert*/ for i=[0, n] bc[i][0] = 1; bc[i][1] = i; for i=[1,n] for j=[2,k] bc [i][j] = bc[i-1][j-1]+bc[i-1][j]; } /*Ergebnis in bc[n][k]*/ Die Zeitkomplexität beträgt O(n*k)
14
Der Binomialkoeffizient: Ein linearer iterativer Algorithms
nenner = zaehler1 = zaehler2 = 0 for i=[1,n] nenner *= i for j=[1,k] zaehler1 *= j for h=[1,n-k] zaheler2 *= h bc = i/(zahler1*zahler2) 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!
Ähnliche Präsentationen
