Ordnen Sie die folgenden Funktionen nach ihrer asymptotischer Komplexität in aufsteigender Reihenfolge: i=1 4i + n = 4 n. i=1 i + 3n = 4 ( n(n+1)

Ähnliche Dokumente
Tutoraufgabe 1 (Sortieralgorithmus):

Grundlagen: Algorithmen und Datenstrukturen

2. Grundlagen. Beschreibung von Algorithmen durch Pseudocode. Korrektheit von Algorithmen durch Invarianten.

f 1 (n) = log(n) + n 2 n 5 f 2 (n) = n 3 + n 2 f 3 (n) = log(n 2 ) f 4 (n) = n n f 5 (n) = (log(n)) 2

lim log 2n n = > 0 Da es einen Limes gibt, gibt es auch einen Limes inferior, der gleich diesem Limes ist.

Abgabe: (vor der Vorlesung) Aufgabe 2.1 (P) O-Notation Beweisen Sie die folgenden Aussagen für positive Funktionen f und g:

2 Wachstumsverhalten von Funktionen

Datenstrukturen, Algorithmen und Programmierung 2

2 i. i=0. und beweisen Sie mittels eines geeigneten Verfahrens die Korrektheit der geschlossenen Form.

Übungsblatt 4. Aufgabe 1. IN8009 Algorithmen und Datenstrukturen Thomas Stibor

3. Übungsblatt zu Algorithmen I im SoSe 2017

Tutoraufgabe 1 (Sortieren): Lösung: Datenstrukturen und Algorithmen SS14 Lösung - Übung 4

Untersuchen Sie, inwiefern sich die folgenden Funktionen für die Verwendung als Hashfunktion eignen. Begründen Sie Ihre Antwort.

Übersicht. Datenstrukturen und Algorithmen. Übersicht. Heaps. Vorlesung 8: Heapsort (K6) Joost-Pieter Katoen. 7. Mai 2015

Kapitel 9. Komplexität von Algorithmen und Sortieralgorithmen

Übung Algorithmen und Datenstrukturen

Datenstrukturen und Algorithmen

Algorithmen und Datenstrukturen

Beispielblatt VU Algorithmen und Datenstrukturen 1 VU 6.0

Tutoraufgabe 1 (Starke Zusammenhangskomponenten):

Übung zur Vorlesung Berechenbarkeit und Komplexität

Übung Algorithmen und Datenstrukturen

Kapitel 9. Komplexität von Algorithmen und Sortieralgorithmen

Algorithmik Kap. 2: Laufzeit von Algorithmen

Algorithmen und Datenstrukturen

Grundlagen: Algorithmen und Datenstrukturen

Aufgabe (Schreibtischtest, Algorithmenanalyse)

1. Übung Algorithmen I

void bellford ( List adjlst [n], int n, int i, int j){ int d[n] = + inf ; d[i] = 0;

Algorithmenbegriff: Berechenbarkeit. Algorithmenanalyse. (Berechnung der Komplexität)

WS 2009/10. Diskrete Strukturen

Algorithmen und Datenstrukturen

UE Algorithmen und Datenstrukturen 1 UE Praktische Informatik 1. Übung 5. Asymptotische Laufzeitkomplexität Definition Regeln Beispiele

Notation für das asymptotische Verhalten von Funktionen

Übung Algorithmen und Datenstrukturen

Übersicht Datenstrukturen und Algorithmen. Literatur. Algorithmus: Wikipedia Definition. Vorlesung 1: Einführung. Prof. Dr.

3.3 Laufzeit von Programmen

Aufgabe 8. 1 Arbeitsweise illustrieren. 2 Korrektheitsbeweis führen. 3 Laufzeitanalyse durchführen.

Algorithmen und Datenstrukturen 1-1. Seminar -

Programmierung 1 (Wintersemester 2012/13) Lösungsblatt 10 (Kapitel 11)

V. Claus, Juli 2005 Einführung in die Informatik II 45

Informatik B von Adrian Neumann

Einführung in die Theoretische Informatik

Algorithmen und Datenstrukturen Tutorium Übungsaufgaben

3 T (d 1, l 2. ) + (6 + 2) falls d > 0 7 sonst. n 2. 4T ( n 2 ) + log 2 (n), falls n > 1 1, sonst

Objektorientierte Programmierung VL: Prof. Dr. Marco Block-Berlitz - Freie Universität Berlin Proinformatik III

Komplexität von Algorithmen Musterlösungen zu ausgewählten Übungsaufgaben

F3 Berechenbarkeit und Komplexität

Algorithmen und Datenstrukturen Kapitel 1 Algorithmen & Algorithmenanalyse

Kostenmodell. Daniel Graf, Tobias Pröger. 22. September 2016 (aktualisierte Fassung 5 vom 9. Oktober 2016)

Algorithmen und Datenstrukturen Wintersemester 2004/ November T(n) = T(n a) + T(a) + n

Algorithmen & Programmierung. Steuerstrukturen im Detail Selektion und Iteration

Informatik I Komplexität von Algorithmen

Tutoraufgabe 1 (Floyd-Warshall):

1. Asymptotische Notationen 2. Zahlentheoretische Algorithmen 3. Sortierverfahren 4. String Matching 5. Ausgewählte Datenstrukturen

Achtung: Groß O definiert keine totale Ordnungsrelation auf der Menge aller Funktionen! Beweis: Es gibt positive Funktionen f und g so, dass

Minimale Spannbäume. Übersicht. 1 Spannbäume. 2 Minimale Spannbäume. 3 Greedy Algorithmen. 4 Die Algorithmen von Kruskal und Prim

Komplexität von Algorithmen OOPM, Ralf Lämmel

Lösung: Datenstrukturen und Algorithmen SoSe 2012, Klausur Lösung

Einführung in die Informatik 2

Effiziente Algorithmen 2

Algorithmen und Datenstrukturen (für ET/IT)

a) Geben Sie für die folgenden Paare von Mengen jeweils die Teilmengenbeziehung mit Hilfe der Symbole, und = an. lässt sich wie folgt umformen:

Thomas Gewering Benjamin Koch Dominik Lüke. (geschachtelte Schleifen)

es gibt Probleme, die nicht berechenbar sind (z.b. Menge aller Funktionen N N und die Menge aller Sprachen sind überabzählbar)

Algorithmen und Datenstrukturen (ESE) Entwurf, Analyse und Umsetzung von Algorithmen (IEMS) WS 2014 / 2015 Vorlesung 3, Donnerstag 6.

Komplexität. G. Zachmann Clausthal University, Germany Leistungsverhalten von Algorithmen

Komplexität von Algorithmen

String - Matching. Kapitel Definition

2. Effizienz von Algorithmen

F3 Berechenbarkeit und Komplexität

Algorithmen und Datenstrukturen

Klausur Theoretische Informatik I WS 2004/2005

Datenstrukturen und Algorithmen

Tutoraufgabe 1 (Vollständige Induktion): Tutoraufgabe 2 (Rotationen): Datenstrukturen und Algorithmen SS15 Übungsblatt 5 (Abgabe 3.6.

Musterlösung zu Blatt 11, Aufgabe 3

Datenstrukturen und Algorithmen

Algorithmische Bioinformatik 1

Technische Universität Wien Institut für Computergraphik und Algorithmen Arbeitsbereich für Algorithmen und Datenstrukturen

Aufgabe 1 O-Notation (2+3+5=10 Punkte)

Schleifeninvarianten. Dezimal zu Binär

8 Komplexitätstheorie

Tag 3 Repetitorium Informatik (Java)

13 (2-4)-Bäume Implementierbare Funktionen. (2-4)-Bäume sind durch folgende Eigenschaften deniert: 1. Alle Äste sind gleich lang

Übungsblatt 2 - Lösung

Musterlösung zum Weihnahchtsübungsblatt. Teil 1 von Martin Fabricius. Aufgabe 1

Übungsklausur Algorithmen I

8. A & D - Heapsort. Werden sehen, wie wir durch geschicktes Organsieren von Daten effiziente Algorithmen entwerfen können.

Vortrag 20: Kurze Vektoren in Gittern

2.2 Allgemeine (vergleichsbasierte) Sortierverfahren

Algorithmen und Datenstrukturen

Grundlagen: Algorithmen und Datenstrukturen

1 Asymptotische Notation

Humboldt-Universität zu Berlin Institut für Mathematik Prof. A. Griewank Ph.D.; Dr. A. Hoffkamp; Dipl.Math. T.Bosse; Dipl.Math. L. Jansen,T.

Algorithmen und Datenstrukturen

Komplexität von Algorithmen:

Der Primzahlsatz. Es gibt eine Konstante A, so daß f(x) g(x) Ah(x) für alle genügend großen x.

Kapitel 5. Textalgorithmen. 5.1 Grundbegriffe

Informatik I Tutorium WS 07/08

Transkript:

für Informatik Prof. aa Dr. Ir. Joost-Pieter Katoen Christian Dehnert, Friedrich Gretz, Benjamin Kaminski, Thomas Ströder Tutoraufgabe (Asymptotische Komplexität): Ordnen Sie die folgenden Funktionen nach ihrer asymptotischer Komplexität in aufsteigender Reihenfolge: n!, n, n log n, n n, n, n, n 3, n, log n, log n, n n. log n n n = log n n log n n n n n 3 n n! n n. für alle n größer als ein gewisses n 0. ( ) Die Aussage n = log n gilt nur für den Logarithmus zur Basis. Tutoraufgabe (Ungleichungen): Zeigen Sie die folgenden Aussagen für beliebige n N >0 : a) n (4 i + 3) 4(n + n) b) n log i log n n c) log n 3 log 4 n a) n (4i + 3) = n 4i + n = 4 n i + 3n = 4 ( n(n+) ) + 3n < 4n + 4n = 4(n + n) 3 b) Diese Aufgabe lösen wir mit Hilfe des Logarithmengesetzes: log a x + log a y = log a (x y).. Möglichkeit:. Möglichkeit n log i = log n log i n i = log n! log n n n log n = n log n = log n n c) Für diese Aufgabe nutzen wir ein weiteres Logarithmengesetz, den Basistausch: log a x = log b x log b a log n = log 4 n log 4 = log 4 n 3 log 4 n

für Informatik Tutoraufgabe 3 (O-Notation): Zeigen oder widerlegen Sie die folgenden Aussagen: a) g(n) = n 3 + 4n + 46 Θ(n 3 ) b) n+ Θ( n ) c) log n O( n) d) max(f (n), g(n)) Θ(f (n) + g(n)) e) g(n) + f (n) O(g(f (n))) (a) Die Aussage gilt: g(n) = n 3 + 4n + 46 Θ(n 3 ) g(n) Θ(n 3 ) c, c R, n 0 N : c n 3 g(n) c n 3 n > n 0 nach Definition Diese Aussage ist für n 0 =, c = c und c = + 4 + 46 = 606 erfüllt. (b) Die Aussage gilt: n+ Θ( n ) n+ Θ( n ) c, c R, n 0 N : c n n+ c n n > n 0 nach Definition c, c R, n 0 N : c n n c n n > n 0 n n n n > c =, c =, n 0 = Alternative n+ lim n n = lim = n Hieraus folgt dass n+ Θ( n ). (c) Die Aussage gilt. Beweise: Wir müssen zeigen dass lim n log n n 0 und lim n log n n <. log n L Hôspital lim = lim n n n ln()n n n = lim n n ln() = 0 (d) Die Aussage gilt. Es ist zu zeigen, dass Folgendes gilt: c, c R 0, n 0 N : c (f (n) + g(n)) max(f (n), g(n)) c (f (n) + g(n)) n n 0 für c, c R 0 und n n 0 für ein hinreichend großes n 0 mit n 0 N. Wir beginnen mit max(f (n), g(n)) c (f (n) + g(n)):

für Informatik Da f (n) und g(n) positive Funktionen sind gilt, (f (n) + g(n)) max(f (n), g(n)). Aus dieser Abschätzung erhalten wir dann unmittelbar: c R 0, n 0 N : max(f (n), g(n)) c (f (n) + g(n)) n n 0 für ein beliebiges c und n n 0. Um den. Teil zu zeigen schätzen wir den Ausdruck f (n) + g(n) nach oben hin ab und erhalten f (n) + g(n) max(f (n), g(n)) f (n) + g(n) max(f (n), g(n)) Hieraus ergibt sich unmittelbar: c R 0, n 0 N : c (f (n) + g(n)) max(f (n), g(n)) für c = (e) Die Aussage gilt nicht, wie wir an dem folgenden einfachen Gegenbeispiel sehen. Für g(n) = und f (n) = n gilt n / O(), denn es gibt kein c R 0, sodass für alle n N gilt: n c Offensichtlich gilt diese Gleichung für kein c R 0, wenn wir n = c + wählen. Tutoraufgabe 4 (Programmanalyse): Gegeben sei der folgende Algorithmus zur Suche von Duplikaten in einem Array: bool duplicate ( int E[], int n) { for ( int i = 0; i < n; i ++) for ( int j = i +; j < n; j ++) if(e[i] == E[j]) return true ; return false ; Er erhält ein Array E mit n Einträgen, für das er überprüft, ob zwei Einträge des Arrays denselben Wert besitzen. Für die Average-Case Analyse gehen wir von folgenden Voraussetzungen aus: Mit einer Wahrscheinlichkeit von 0.3 gibt es im Array ein Duplikat. Es gibt immer maximal ein Duplikat. Wenn ein Wert doppelt enthalten ist, so steht dieser Wert an der ersten Position im Array. Das zweite Auftauchen des Wertes ist an jeder (anderen) Position gleich wahrscheinlich. Bestimmen Sie in Abhängigkeit von n... 3

für Informatik a) die exakte Anzahl der Vergleiche von Einträgen des Arrays im Best-Case. b) die exakte Anzahl der Vergleiche von Einträgen des Arrays im Worst-Case. c) die exakte Anzahl der Vergleiche von Einträgen des Arrays im Average-Case. Wie in der Aufgabe gefordert zählen wir in dieser Aufgabe nur Vergleiche mit Einträgen Im Array, nicht aber der Vergleich, der in der der Schleifenbedingung stattfindet. a) Best-case Analyse B(n) Die kleinste Anzahl von Vergleichen wird erreicht, wenn die ersten beiden Positionen den gleichen Wert haben. Dann ist lediglich ein Vergleich nötig. Eine Ausnahme bildet der Fall, dass das Array leer ist oder nur ein einziges Element enthält (n ), dann findet kein einziger Vergleich statt. Somit ergibt sich: { 0,falls n B(n) =, sonst b) Worst-case Analyse W (n) Die meisten Vergleiche ergeben sich, wenn kein Duplikat im Array vorhanden sind. In diesem Fall wird die äussere Schleife vollständig durchlaufen (n-mal) und auch die innere Schleife wird jeweils vollständig durchlaufen. Hierbei wird die innere Schleife beim i-ten Durchlauf der äusseren Schleife (n i)-fach durchlaufen. In jedem Durchlauf der inneren Schleife findet ein Vergleich statt. Somit ergibt sich eine Gesamtanzahl von Vergleichen im Worst-case von: W (n) = (n i) = (n ) i = n (n ) i=0 i=0 i=0 (n ) n = n (n ) c) Average-case Analyse A(n) Die Average-case Vergleichsanzahl ergibt sich wie folgt aus der Anzahl der Vergleiche A Duplikat (n) für den Fall, dass ein Duplikat enthalten ist, sowie A Duplikat (n) für den Fall, dass kein Duplikat enthalten ist: A Duplikat (n) 0, 7 + A Duplikat (n) 0, 3 Wie bereits in Aufgabenteil b) bestimmt, gilt A Duplikat (n) = W (n) = n (n ). Für den Fall, dass ein Wert x an zwei Positionen steht, steht x unter anderem an der ersten Position im Array. Das zweite Auftreten ist an jeder weiteren Position gleich wahrscheinlich, d.h. mit einer Wahrscheinlichkeit von n steht der Wert x an Position i < n. Um ein Duplikat an den Stellen 0 und i zu entdecken, wird die äußere Schleife einmal ausgeführt, die innere wird i-mal durchlaufen. Es ergibt sich die folgende Anzahl von Vergleichen für A Duplikat : A Duplikat (n) = P r{e[i] = x j. j < n E[0] = E[j] t(e[0] = E[i]) ( ) = n i = n n i = (n )n n = n 4

für Informatik Somit ergibt sich eine Average-case Vergleichszahl von: A(n) = n(n ) 0, 7 + n 0, 3 Aufgabe 5 (Asymptotische Komplexität): Begründen oder widerlegen Sie die folgenden Aussagen: (5 3 Punkte) a) n O(n 0n 50). b) 3n 3 + n 34n + 00 O(n 3 ). c) Aus f (n) Ω(g(n)) und f (n) O(h(n)) folgt g Θ(h(n)). d) Aus f (n) Θ(n) folgt f (n) O( n ). e) log a (n) Θ(log b (n)) für zwei beliebige Konstanten a, b >. (a) Im folgenden ist p(n) = n 0n 50. Wir wählen einfach (zum Beispiel) c =. Jetzt müssen wir zeigen, dass es ein n 0 gibt, sodass n cp(n) für alle n > n 0. Äquivalent dazu gilt 0 cp(n) n = n 40n 500 für alle n > n 0. Mithilfe der pq-formel finden wir n 40n 500 = (n + 0)(n 50). Das gesuchte n 0 ist also 50. (b) Wir wählen c = 3 + + 00 = 5 und n 0 =. Offensichtlich gilt 3n 3 + n 34n + 00 3n 3 + n + 00 3n 3 + n 3 + 00n 3 = 5n 3 für n und die Aussage ist gezeigt. (c) Stimmt nicht, wähle z.b. f (n) = n, g(n) =, h(n) = n. Es gilt n Ω() und n O(n ) aber Θ(n ). (d) Stimmt nicht, wähle z.b. f (n) = n. Dann ist aber 4 n O( n ). (lim n n 4 n = lim n ( 4 )n = 0). (e) Die Aussage gilt. Zu zeigen ist: c, c R >0, n 0 N, n N mit n n 0 : c log b (n) log a (n) c log b (n) Aus den Logarithmengesetzen folgt log a (n) = log b(n) log b (a). Wähle also c = c = a, b > gilt und damit auch > 0. Damit erhalten wir log b (a) und damit ist die Aussage bewiesen. c log b (n) = log a (n) = c log b (n) log b (a). Dies ist möglich, da 5

für Informatik Aufgabe 6 (Beweis): (3+6 Punkte) Wir wollen beweisen, dass n! und n n nicht dieselbe Komplexität haben, also n! Θ(n n ). Führen sie dazu folgende Schritte aus. a) Zeigen Sie zunächst, dass n! o(n n ). Hinweis: es gilt allgemein f (n) o(g(n)), wenn lim n f (n) g(n) = 0. b) Zeigen Sie nun, dass für eine beliebige Funktion g gilt: o(g(n)) Θ(g(n)) =. Hinweis: es bietet sich ein Widerspruchsbeweis an. Folgern Sie schließlich die oben gewünschte Aussage. a) Wir stellen fest, dass n! n n = n n n n n n. Die Ungleichung gilt, da jeder Faktor nicht größer als ist. Daher gilt für alle n 0 n! n n n. Das Sandwichlemma aus AfI erlaubt die Schlussfolgerung: Aus lim 0 = 0 = lim n n n folgt n! lim n n n = 0. b) Per Definition gilt Θ(g(n)) = {f (n) es gibt positive Konstanten c, c, n 0 sodass für alle n n 0 gilt 0 c g(n) f (n) c g(n) und o(g(n)) = {f (n) für alle c > 0 existiert ein n 0 sodass für alle n n 0 gilt 0 f (n) < cg(n). Zum Zwecke des Widerspruchs nehmen wir an es gäbe eine Funktion f, die im Schnitt der beiden Mengen liegt. Dann gibt es auch Konstanten c und n 0, sodass Gleichzeitig muss es für c ein ñ 0 geben, sodass c g(n) f (n) für n n 0. f (n) < c g(n) für n ñ 0. Somit gibt es ein n, das größer als n 0 und ñ 0 ist, für das gilt c g(n ) f (n ) < c g(n ). Das ist ein Widerspruch! Damit wissen wir, dass n! o(n n ) und da o(n n ) und Θ(n n ) keine gemeinsamen Funktionen besitzen folgt die gewünschte Aussage n! Θ(n n ). Der Einschnürungssatz, Einschließungssatz, Dreifolgensatz oder Sandwichsatz (u. a.: Schachtelungssatz, Quetschkriterium resp. Satz von den zwei Polizisten; englisch sandwich theorem) ist in der Analysis ein Satz über den Grenzwert einer Funktion. Gemäß dem Einschnürungssatz strebt eine Funktion, die von oben und unten durch zwei gegen denselben Wert strebenden Funktionen eingezwängt wird, auch gegen diesen Wert. [http://de.wikipedia.org/wiki/einschn%c3%bcrungssatz] 6

für Informatik Aufgabe 7 (Programmanalyse): (++3 Punkte) Gegeben sei ein Algorithmus zur Suche eines Modus (einer am häufigsten vorkommenden Zahl) in einem Array: int findmodus ( int [] E) { int i = 0; int [] counter = {0,0,0,0; // Zaehlt Vorkommen der Zahlen 0 bis 3 boolean flag = false ; int haelfte = ( int ) Math. ceil (E. length /.0); // Bei ungerader Laenge // des Arrays runden wir auf while (! flag && i < E. length ) { int number = E[i]; counter [ number ]++; if( counter [ number ] >= haelfte ) { flag = true ; i ++; return getmaxcount ( counter ); // Extrahiert einen Modus aus dem Zaehler in // konstanter Zeit Er erhält ein Array E von Zahlen zwischen 0 und 3 und findet heraus welche dieser vier Zahlen am häufigsten in E vorkommt. Bei Betrachtung der Laufzeit vernachlässigen wir die Initialisierung der Variablen sowie den Aufruf von getmaxcount(counter), da diese Operationen unabhängig von der Eingabe E immer konstante Laufzeit haben. Wir interessieren uns lediglich für die Anzahl der Schleifendurchläufe, von denen jeder einzelne Durchlauf eine Zeiteinheit kostet. Sei n die Länge des Arrays E. Bestimmen Sie in Abhängigkeit von n... a) die Anzahl der Schleifendurchläufe im Best-case. b) die Anzahl der Schleifendurchläufe im Worst-case. c) die Anzahl der Schleifendurchläufe im Average-case. Hierzu nehmen wir an, dass in E eine vorkommt und alle anderen Einträge gleich 3 sind. Die kann jedoch an jeder der n Positionen gleich wahrscheinlich auftreten. a) Im besten Fall kommt in den ersten n Positionen die gleiche Zahl vor und die Schleife bricht nach ebenso vielen Iterationen ab, da der Modus unabhängig von den restlichen Einträgen bereits feststeht. b) Im schlechtesten Fall muss das gesamte Array durchlaufen werden. Es gibt dann also genau n Iterationen. c) Der Modus ist offensichtlich 3, die Frage ist lediglich nach wie vielen Schritten wir das feststellen werden. Es gibt zwei Fälle, entweder kommt die in der zweiten Hälfte des Arrays vor und wir haben die Best-case Laufzeit oder die kommt in der ersten Hälfte vor und wir brauchen eine Iteration mehr. Genauer gilt für gerade n A(n) = n + ( n ) + = n +. Falls n ungerade ist erhalten wir analog A(n) = n n + = n + 4n + 3 4n n + 3 + n 4n + n n n + = n + 4n + 4n = n + + n. 7