Auf ein... Ist das eine Meldung? Ach so, moin.
Auf ein vorletztes Mal, Alter. Bisschen laut. So,
genau, heute hatte ich ja gestern noch rumgeschrieben, heute Zusammenfassung.
Und nachher, wenn wir noch Zeit haben, irgendwie noch
ein bisschen Repetitorium. Und nächstes und letztes Mal dann
ganz viel Repetitorium und in zweieinhalb Wochen schon die Klausur.
Leider auf dem Samstag. Sechster, zweiter,
wenn ich mich nicht irre. Also der erste Samstag irgendwie
im Februar
Ich weiß ehrlich gesagt noch gar nicht, ob wir da reinkommen und so.
Ich musste nochmal gucken, aber ich denke mal,
wir kommen da irgendwie rein und ich hoffe,
ich kriege die Klausuren da auch hin und so.
Und dann ist am 6.2. die Klausur. Genau, habt ihr
noch Fragen dazu? Anmelden müsst ihr euch über Stine,
Studienbüro und so. Mitschreiben dürft ihr natürlich nur,
wenn ihr angemeldet seid. Wir korrigieren möglichst schnell danach,
sodass die Noten hoffentlich Montag, Dienstag dann da sind.
Sonst noch Fragen dazu zum Organisatorischen. Nee, ne?
Alles klar. Gut, dann Zusammenfassung oder vorher ein bisschen
was zur Klausur, wie die so aufgebaut ist und
so weiter
Was ist klausurrelevant? Also die Vorlesung halt und die Aufgabenzettel und
die Musterlösung. Das ist so das, was klausurrelevant ist.
Wenn ihr an irgendeiner Stelle irgendwie mit der Vorlesung nicht klarkommt,
also mit den Folien nur, dann guckt man im Kommen nach.
Alles, was wir behandelt haben, ist irgendwie aus dem
Buch rausgenommen. Und manchmal ist es ja so,
dass an irgendeiner Stelle in den Folien,
dass da irgendwie dann ein Schritt zu schnell geht oder so.
Und dann liest man das im Kommen nach und denkt,
oh, wenn der Absatz da gewesen wäre, dann hätte ich sofort verstanden.
Deswegen guckt da nochmal nach. Und hier die Anmerkung,
das ist uns erst beim Korrigieren aufgefallen.
Ich habe auf die, letztes Mal haben die ja Flüsse gemacht.
Und in der Definition, die ich da benutze,
das ist quasi die Definition aus, ich glaube,
der zweiten Auflage aus dem Korn aus der ersten und der zweiten Auflage.
Und in der neuen Auflage hatte die Definition
ein bisschen geändert
Falls das irgendwie in der Klausur drankommt, werde ich mich
da an die Definition halten, die wir in den Folien gehabt haben.
Das ist auch nur ein minimaler Unterschied,
aber guckt euch halt die Definition aus den Folien nochmal an.
Genau, und alles andere müsste eigentlich stimmen, so ich bin nochmal geguckt.
Alles andere müsste genauso sein, wie das in allen Auflagen vom Kommen ist.
So, dann, was solltet ihr so ganz generell wissen? Wir haben ja mehrere Algorithmen behandelt und wir haben ihre Themenblöcke behandelt,
aber so ständig ploppten irgendwelche Algorithmen auf,
was ja für jeden nach Möglichkeit wissen sollte,
dass irgendwie, wie sieht die Eingabe aus,
also was ist eigentlich das Problem, mit was arbeite ich da,
muss ich ein Arrey von Zahlen sortieren,
das ist irgendwas anderes, was ich sortieren soll,
eine topologische Sortierung beim Grafen,
das ist auch eine Sortierung,
aber da kriege ich als Eingabe eben keine Zahlen,
sondern irgendwie einen Grafen
Dann, wie sieht die Ausgabe aus?
Also was ist das Ziel? Kriege ich irgendwie nur eine
Zahl raus oder kriege ich wieder eine sortierte Liste raus?
Laufzeit wäre gut, wenn er die für alle Algorithmen wisst,
die wir hatten. Einfach so als Wissen. Und dann,
was ist die Idee und wie arbeitet der Algorithmus?
Das bedingt sich so ein bisschen so, wenn man die Idee kennt,
weiß man meistens auch, wie er arbeitet.
Und je genauer, desto besser halt. Sollte ich das
auch nochmal. Und dann solltet ihr die wichtigen Algorithmen,
was immer das jetzt genau bedeutet, die wichtigen Algorithmen,
die solltet ihr halt an kleinen Beispielen ausführen können.
Wichtig bedeutet eigentlich so die Algorithmen,
wo wir irgendwie einen Schwerpunkt hingesetzt haben
Bubble Sword zum Beispiel haben wir irgendwie nur mal so im Vorbeigehen behandelt,
den muss man jetzt vielleicht nicht ausführen können.
Irgendwie so Algorithmen wie Kruskal oder so haben wir sie im Detail behandelt,
den sollte man vielleicht ausführen können. Außerdem kann man sich so,
wenn man jetzt ein bisschen Schwerpunkt dazu machen möchte beim Lernen,
kann man sich ein bisschen überlegen,
so welche Algorithmen sind denn auch auf dem Papier ganz gut ausführbar und welche nicht.
Bei einigen macht es irgendwie keinen Sinn, die abzufragen auf
dem Papier, bei anderen kann man das gut machen.
Also Standardbeispiel, so Kruskal lässt sich gut abfragen.
Flüsse bei Floyd Warshell so, das lässt sich nicht gut abfragen.
Wer das noch so in Erinnerung hat,
da war so ständig dieses, ich bestimme diesen anderen Grafen,
dann bestimme ich darin Erweiterungsfahrt,
dann habe ich wieder einen neuen Fluss in meinem ursprünglichen Grafen,
dann bestimme ich wieder den neuen Grafen und so weiter.
Da muss man ständig den Grafen neu malen,
so das macht keinen Spaß
Das Einzige, was man da abfragen könnte, wäre irgendwie ein Schritt in der Rechnung. Also dass man irgendwie sagt,
so gegeben dieser Graf mit dem aktuellen Fluss da drin,
zeichnen sie doch jetzt mal den zugehörigen anderen Grafen mit dem neuen Erweiterungsfahrt oder so,
dass man einen Schritt da drin macht. Sowas könnte man abfangen. So,
dann da einmal, um euch ein bisschen zu motivieren,
dass man jetzt sagt, so irgendwie so,
warum lerne ich das jetzt irgendwie genau diesen Algorithmus zum Ausführen,
außer jetzt irgendwie für die Klausur,
wenn ihr die ganzen Ideen von den Algorithmen könnt,
dann könnt ihr eben auch, wenn ihr euch irgendwie ähnliche Probleme begegnen, das benutzen.
Also wenn ihr zum Beispiel Quicksort irgendwie so in Erinnerung haltet,
dass man sowohl vom linken als auch vom rechten Ende anfängt,
in dem Array zu arbeiten und dann irgendwie von links und rechts sich in die Mitte zu nähern und währenddessen zu sortieren,
wenn man sowas hat,
dann kann man irgendwie bei anderen Algorithmen auch sowas benutzen,
dass man irgendwie denkt so, hey,
vielleicht lese ich nicht einfach nur,
dass Array von links nach rechts durch,
sondern ich fange von beiden Seiten an und mische irgendwie oder mache irgendwas so,
ne?
Oder von, ja. Ja, also die Frage war
gerade, ob man den Algorithmus vielleicht auch beschreiben sollte.
Also so hier in diesem Setting, was ist die Idee,
wie arbeitet der Algorithmus? So klassische Aufgaben sind irgendwie gegeben
dieser Graf, Sie mal Kursgeiles Algorithmus an.
So, dann machst du das halt irgendwie, ne?
Und erzählst zuerst nehme ich die Kante, dann nehme ich die Kante.
Andere Variante wäre, dass man sagt, sie kennen doch Kursgeiles Algorithmus,
beschreiben sie doch mal so grob, wie der funktioniert. Und dann sagst du,
also jetzt sollst du nicht irgendwie dem Pseudo-Code im Detail angeben,
sondern irgendwie sagen, naja,
ich sortiere die Kanten vorher und dann nehme ich immer die mit dem günstigsten Gewicht,
das sei denn, es entsteht ein Kreis,
also irgendwie so auf der Ebene,
dass man es auf der Ebene beschreiben kann.
Also eher die Idee, genau, oder bei,
keine Ahnung, bei Merch Souls sagt man,
ich halbiere das Area immer weiter und sortiere dann die einzelnen Elemente rekursiv weiter,
dass man so auf der Ebene die Algorithmen,
die wir hatten, so beschreiben kann.
Genau, dann, wie ist die Aufteilung in der Klausur
Erstmal von den Themen her, so grob so,
wie das der Zeit ungefähr entsprach, die wir in der,
in der Vorlesung dafür benutzt hatten, also so 25 Prozent U-Notation,
Rekurrenzgleichung und steht da jetzt gerade nicht.
Und Laufzeitanalyse, also gegeben irgendwie so ein Stück Source-Code,
welche Laufzeit hatte. Also irgendwie sowas wie, ne,
VI gleich 1 bis N, 4J gleich 1,
bis 4N und dann Print I und J, dann weiß man irgendwie,
oh, ich habe zwei geschachtelte Vorschleifen, oh, von Endquadrat.
Irgendwie sowas, ne? Oder eben für einen rekursiven Algorithmus,
dass man irgendwie weiß, oh,
da wird zweimal die Methode wieder neu aufgerufen.
Beide Male mit dem Drittel des Arrays,
dann ist das irgendwie sowas T von N gleich zweimal T
von Enddritteln oder irgendwie sowas,
dass man sowas aufstellen kann
Dann sortieren und suchen, was wir da so hatten,
inklusive Suchbäume, Heeps, all solche Geschichten.
Bei Sortieren und Suchen ist so ein bisschen das Problem,
zu den ganzen Sortierverfahren, die wir so hatten,
also Merch, Sort, Quicksort, Insurgentsword und so weiter,
da lässt sich nicht so richtig gut jetzt irgendwie der Algorithmus zu abfragen.
Da können wir vielleicht mal fragen, was die Idee davon ist,
aber bei Grafen nachher hatten wir halt viel mehr Algorithmen,
die man gut ausführen kann.
Das heißt, was wir suchen und Sortieren meisten,
macht es irgendwas mit Heeps zu fragen und Suchbäumen und dann gibt es halt
meistens so einen Bereich, wo man einfach das Wissen abfragt.
Also irgendwie kennen sie einen Sortieralgorithmus, der NO von N abläuft,
ja, also kennen sie so einen und dann so,
ja und wie heißt der und dann ist das halt Counting Sword und was zeichnet den irgendwie aus,
dass da halt keine Vergleichen und Operationen benutzt,
sondern irgendwie anders arbeitet,
dass man sowas erzählen kann
Genau, dann 30 Prozent Graphen und ungefähr 20 Prozent PNP
und sowas. Wahrscheinlich verschiebt sich das so ein bisschen,
dass da ein bisschen mehr bei Graphen ist und ein bisschen
weniger bei den oberen beiden, aber so ungefähr stimmt das.
Das so zu dem thematischen und zur Art der Aufgaben
und zum Schwierigkeitsgrad der Aufgaben sieht das ungefähr so aus,
dass so 60 bis 70 Prozent Aufgaben sind,
wo man Verfahren benutzen soll,
wo man vielleicht ein bisschen rumrechnen soll oder wo man Wissen irgendwie wiedergeben soll.
Darunter stehen so drei typische Aufgaben im Binären suchbar und was
löschen und dann halt gegeben der binäre Suchbaum und irgendwie gesagt,
löschen sie mal die 17 und dann löscht man die halt
und muss irgendwie angeben,
wie der Binärbaum danach aussieht
Sowas wie das hier, da würde man ja schon sagen,
das ist ja kein Verfahren mehr benutzen,
aber wenn man halt weiß, was man tun soll,
dann ist das so Rechnen auf so einer Ebene,
wo man sagen würde, okay,
da muss man jetzt wirklich nicht mehr kreativ sein,
da muss man ja irgendwie nur rechnen,
da muss man das einmal durcheinander teilen und irgendwie gucken,
wo das hingeht, wenn Endgegen unendlich geht und dann ist man schon fertig,
wenn das jetzt irgendwie hier komplexer wird,
also wenn das dann plötzlich so was ist,
wo man will da rumrechnen muss oder irgendwie diese Regel von L Hobby Teil anwenden muss oder so,
dann rutscht das halt irgendwie diesen zweiten Aufgabenblock, dass man dann sagt,
so 30 Prozent, 20, 30 Prozent schwierigere Verfahren,
spezielles Wissen irgendwie oder irgendwie kreativ sein in einem Umfeld,
in dem man sich schon auskennt,
dass man irgendwie sagt,
eine NP Vollständigkeitsbeweis mit nur einer ganz geringen Variation zu etwas,
was wir schon hatten.
Also wenn wir irgendwie hatten,
von Dreikoll auf 8 Call zu reduzieren und jetzt wird gefragt,
von Dreikoll auf 6 Call, dann ist das irgendwie faktisch das Gleiche.
Also wenn man sich das nochmal angeguckt hat in der Musterlösung,
der weiß, was man da tun muss,
dann passiert ja nicht so viel Neues.
Wobei die NP Vollständigkeitsbeweise meistens schon so in diese unteren 10 Prozent rutschen. Genau,
die letzten 10 Prozent sind dann eben so schwierigere Aufgaben,
vielleicht in etwas schwieriger,
in viel Vollständigkeitsbeweis oder in etwas schwieriger Algorithmenentwurf oder so
Und da unten könnt ihr so sehen, wo man so landet,
irgendwie punktemäßig. Und wie gesagt, das hier,
also eher so 60 bis 70 und das hier eher so 20 bis 30.
Dass man also schon mit,
wenn man die ganzen Verfahren benutzen kann und so,
dann landet man irgendwie hier bei den Dreier, zwei Jahren.
Und dann, wenn man ein bisschen auch die schwierigeren Verfahren kann,
wird das halt immer besser, ne?
Ja, Fragen dazu. Erst zum Zweiten. Dann da nochmal
so in Fettdruck. Ich mache jetzt mal eine Zusammenfassung,
ob ich jetzt relativ flott durch. Das dient primär dazu,
dass ihr bei allem nochmal irgendwie seht, ah ja,
das waren die Begriffe und ob ihr abhaken könnt,
ja,
kann ich oder kann ich nicht
Wenn ihr bei irgendwas in der Zusammenfassung jetzt das Gefühl habt,
irgendwie, uh, verstehe ich nicht,
dann solltet ihr nicht die Zusammenfassungsfolien halt zum Wiederholen dieses Themenbereichs nutzen,
sondern irgendwie den ursprünglichen Foliensatz,
die ursprüngliche Vorlesung oder eben auch das im Kommen nochmal nachlesen.
Bei einigen Stellen wird das offensichtlich sein. Bei einigen Stellen
steht da nämlich nur, wir hatten das und das Verfahren,
da kann man jetzt die Zusammenfassungsfolien gar nicht benutzen,
um das zu wiederholen.
Aber bei einigen Stellen geht es halt auch ein bisschen mehr in die Tiefe so.
Das verleitet so dazu, dass man irgendwie denkt so,
oh, die Stelle verstehe ich gerade bei der Zusammenfassung nicht oder so.
Naja, und dann wird aber bei der Zusammenfassung vielleicht drei Schritte übersprungen,
sprich, wenn man das gerade nicht versteht,
das kann man dann auch quasi aus den Zusammenfassungsfolien gar nicht unbedingt rauslesen.
Also guckt euch dann,
wenn ihr in bestimmten Themenbereichen nicht versteht,
nochmal die Folien der Zusammenfassung an
Genau. Und nach der Vorlesung, ach ja,
stelle ich noch die Sammlung von klausurtypischen Aufgaben ins Netz.
Das sind deutlich mehr, als es nachher Klausuraufgaben gibt.
Das ist einfach nur so, dass ihr mehr zum Üben habt.
Da ist jeder von den Themenbereichen,
die wir gleich jetzt so wiederholen, ist da abgedeckt.
Wenn ihr das alles könnt, habt ihr mit der Klausur keine Probleme.
Also außer vielleicht bei diesen oberen fünf bis zehn Prozent,
wo man dann vielleicht an irgendeiner Stelle kreativ sein muss und
dann ausgerechnet, weil der Klausur nicht draufkommt oder so.
Das kann immer passieren. Aber normalerweise, wenn ihr das alles könnt,
solltet, das sollten auch die gut gehen.
Gut, munter rein. Unnotation und Rekurrenzgleichung, der erste Block
Honotationen. Das sah so aus. Worum ging es da?
Da ging es darum, irgendwie zwei Funktionen zu klassifizieren,
dass man irgendwie sagen kann,
F ist asymptotisch kleiner als G oder kleiner Gleichgeh.
Und dieses Asymptoch bezog sich immer darauf,
dass das erst irgendwie ab so einem gewissen N0 gilt.
Also am Anfang dürfen die sich noch irgendwie anders verhalten,
aber ab einem gewissen Startpunkt N0 ist die eine wirklich immer
kleiner als die andere oder kleiner gleich.
Wobei man die eben noch mit so einer konstanten C
nach oben oder unten schieben darf.
Und dann sagt man eben, F ist in OphonG,
wenn eben F von N kleiner gleich zehnmal G von N
ist,
ab irgendeinem gewissen
Und bei den anderen sieht das alles so ähnlich aus mit der Ausnahme,
dass dieses kleine, gleich größere Gleichzeichen ein bisschen flippt.
Und hier wird aus dem Existierten für alle. Genau,
und damit rechnet man üblicherweise jetzt nicht so,
sondern man nimmt irgendwie diese Liebesnotation,
dass man irgendwie sagt, FSN Ufong, genau dann,
wenn dieser Liebes von F&N durchgeht von N eben kleiner ist als unendlich.
Und dann gab es irgendwie diese fünf Bedingungen hier.
Und was man dann eben immer macht, ist irgendwie,
man teilt F&N durch G von N,
lässt den Liebes gegen unendlich gehen und guckt, was da irgendwie rauskommt.
Und manchmal, wenn sie hier mit ihm nicht so gut arbeiten lässt,
dann benutzt man auch diesen Satz von L-Hobby teil.
Also man denkt, wie sowas hat wie Login durch Ende,
dann kann man das irgendwie nicht direkt machen und dann arbeitet
man eben mit dieser Regel,
bildet bei beiden die Ableitung und kann damit dann
weiter rechnen
Und kommt dann zu seinem Ergebnis. Warum? Und da
so typische Klausuraufgaben irgendwie ist Endquadrat in O von Endhoch 3 ja oder nein,
so, ne, und dann rechnet man eben einmal aus und weiß, ob das gilt oder nicht.
Genau, dann da zu merken, so FNU von G,
wenn F kleiner gleich G ist, in Omega fungieren,
wenn es größer gleich G ist, in Täter,
wenn sie gleich sind, dann eben in kleinen Uhr und kleinen Omega,
wenn es echt klein oder echt größer ist,
immer so bezüglich diesem asymptotisch.
Ja, aber das ist nur eine Merkhilfe,
das hier solltet ihr halt benutzen, um das auszurechnen oder alternativ auch das.
Damit ist meistens einfacher. Und dann kann man das irgendwie klassifizieren.
Genau, und dann hatten wir so mehrere Sätze,
um die irgendwie in Zusammenhang zu setzen, diese ganzen O-Omega- und Täter-Notationen.
Dann hat man eben gesagt,
wenn FNO von G ist und GNO von Haden impliziert das
auch FNO von Hane und so von dieser Merkhilfe von eben
kann man sich das auch meistens relativ schnell klar machen,
wenn F-Kleine gleich G ist und G,
Kleine gleich Haar, dann ist auch F-Kleine gleich Haar,
so okay
Und das kann man dann eben für alle auch irgendwie beweisen.
Und ein paar haben wir auch gemacht in der Vorlesung.
Wenn ihr üben wollt, Recht versucht sie alle zu beweisen,
dann könnt ihr das irgendwie aus dem FF.
Ist es die Märkhilfe einigermaßen genau,
dass das also an die Abgleichung nicht für die Berghilfe gilt?
Es gelten ja keine Gleichung für die Merkel,
für die Merkel ist es nur eine Merkhilfe,
dass man irgendwie sagen kann, naja,
so grob stimmt das so,
aber dann kann ich nichts beweisen und nichts machen
Also es gelten keine Gleichung für die Merkel oder irgendwie sowas.
Das ist nur so, dass man so grob eine Vorstellung
davon hat, ah ja, so verhält sich das.
Und für die Dinger kann man das halt ganz gut benutzen,
weil man dann irgendwie weiß, naja,
hier F in O von Omega oder Täter von F,
naja, wenn da überall dieses Gleich steht bei der Merkhilfe,
dann müsste das passen.
Und dann muss man es aber noch beweisen.
Also man kann jetzt nicht losgehen und sagen, naja,
nach der Merkhilfe geht das. Ja, noch mehr Sätze. Ja,
hier auch irgendwie, wenn Uth, Darwin klein geht,
wenn G in kleinen O von F ist,
dann ist G also echt kleiner Wie F?
Ja, dann ist G auch kleiner, gleich F.
So von den Merkelfen ist das immer klar. Solche Dinger
hier lassen sich auch ziemlich gut mit diesen Liebesnotationen beweisen.
Wenn man weiß, geh es in Klein-O von F,
dann weiß man hier, dass der Liebes hier gegen Null geht.
Naja, wenn der Liebes gegen Null geht,
dann ist der ganz bestimmt kleiner als unendlich.
Also es ist auch ein großes O. Also so solche Dinger
irgendwie beweisen können, so kleinere Sachen.
Und da zuletzt so ein bisschen so Abschlusseigenschaften.
Genau, was man auch machen können soll,
ist dann eben diese Code-Analyse gegeben, so ein sequenzielles Stück Code,
dass man da dann sagen kann, oh, okay,
die Laufzeit davon ist jetzt von oben beschränkt durch Of und End-Quadrat,
oh, von der Hoch 3,
Of und End mal Login, irgendwie solche Geschichten.
Genau, da die wichtigen Funktionen, konstanten Logorithmen,
Wurzeln, Polynome, Exponentialfunktion, Kombinationen davon.
Weitere brauchen wir eigentlich gar nicht. Und die Wurzelfunktion hier,
die lässt sich meistens halt gut schreiben als N hoch,
eineinhalb, dann kann man damit auch gut rechnen bei dieser Liebesgeschichte,
wenn man da irgendwie teilen will und so.
Fragen dazu zur Unnotation. Also Definition kennen, damit rechnen
können und gegebenenfalls eben so kleinere Sätze damit beweisen können.
Das ist ohne Unterziehung. Rekurrenzgleichung, das waren die Gleichung,
die auftraten, wenn man rekursive Algorithmen analysieren will. Ja,
und dann kam man irgendwie,
das war das Beispiel von den Türme von Hanoi,
dass man irgendwie gesagt hat, naja, wenn N gleich 1 ist,
wenn ich also nur noch eine Scheibe habe bei diesem Türmen von der Neue,
dann brauche ich nur einen Schritt,
um das von A nach C zu bringen.
Und wenn ich mir als eine Scheibe habe,
dann muss ich eben irgendwie einmal die oberste irgendwo hinbringen und
dann zweimal das Problem lösen mit N minus 1 Scheiben,
so.
Und dann kommen wir irgendwie zu dieser Rekurrenzgleichung
Und dann gab es drei Methoden, das zu machen.
Die erste war, ein paar Werte einzusetzen,
dann eine Lösung zu raten und die zu beweisen.
Das konnte man hier relativ gut machen, dass man gesagt hat,
naja, was kommt denn bei zwei raus,
bei drei raus, bei vier raus, bei fünf raus?
Und dann kommt man irgendwie die Lösung erahnen und die halt beweisen.
Und die anderen beiden Methoden waren eben durch rekursives Einsetzen,
was wir jetzt hier nochmal sehen, oder bei Rekurrenzgleichung,
wo hier nicht sowas steht wie ein minus eins,
sondern wo da so ein Bruch steht,
so ein Drittel oder sowas,
da konnte man dann
dieses Mastertheorien benutzen
Und hier nochmal zum Abwickeln. Man fängt dann halt an und sagt, okay,
Tee von N ist zwar immer T von N minus 1
und dann geht man eben in diese gleiche Gleichung hier wieder rein,
nur eben mit T von N minus 1.
Dann steht hier im T von N minus 1 und hier
steht dann zweimal Tee von N minus 1, minus 1,
also minus 2 plus 1. Und dann setzt man das ein,
rechnet hier vorne irgendwie aus, zweimal alles,
was in der Klammer steht und dann macht man immer so weiter.
Tee von N minus 2 Einsätzen,
Telefon N minus 2 gleich zweimal Tee von N minus 2,
minus 1, plus 1 und immer so weiter,
wieder ausklammern, zack, so weiter.
Dann sieht man hier schon irgendwie 1, 2,
4, kann man schon mutmaßen, irgendwie 8,
16 und so weiter.
Und dann vermutet man eben, dass das
irgendwie so nachher aussieht
Und die muss man dann,
die Zeilung muss man dann eben irgendwie mit vollstehenden Optionen beweisen.
Oder nachher das Ergebnis. Und wichtig ist dann hier darauf
zu kommen, wann das abbricht. Und muss man eben gucken,
hier, das bricht ab, wenn das Argument eins ist.
Ja, und dann setzt man dieses N-K gleich eins,
in minus Chaos gleich eins, genau dann,
wenn K gleich N minus eins ist.
Und dann rechnet man damit weiter. Man bricht die Rekussion
ab, bei K gleich N minus eins,
dann setzt man das hier überall ein.
Und genau, dann geht das hier eben bis zwei hoch
N minus eins und dann hat man halt zwei hoch
N minus eins, zwei hoch N minus zwei, zwei
hoch N minus drei und
so weiter
War jetzt ganz genau ausgerechnet, da kommt jetzt,
als Argument kommt jetzt hier eins raus und Tee von eins ist eins,
das heißt die zwei auch in minus eins bleiben da ein Verstehen.
Und dann hat man eben die Summe von zwei hoch 0 bis zwei hoch
n minus eins, dann kann man das noch ausrechnen mit
dieser einen Formel und dann kriegt man das als Lösung raus.
Also tief und Ende ist zwei hoch n minus eins und das ist eben in Täter von zwei hoch n. Wenn was mit Abwickeln kommt,
dann eher so sowas wie das hier, also in,
was weiß ich, viermal Tee von n minus zwei,
dreimal Tee von n minus drei oder so,
da kann man jetzt beliebig sowohl darum spielen,
an dem Faktor von dem Tee, als auch hier irgendwie an dem,
was man abzieht, als auch da,
was da irgendwie drauf summiert wird.
Das sind so die drei Stellschrauben, da geben sich halt
beliebig viele Aufgaben so. Aber da sieht man hier,
dass das irgendwie so vom Abwickeln, dass das relativ okay geht,
wo das irgendwie komplizierter ist, ist bei den Dingern hier.
Dann hat man hier irgendwie einen Bruch, da hat man
hier auch sogar noch so einen Bruch und dann wird das irgendwie hässlicher.
Da würde man jetzt auch eher das Mastertheorien benutzen,
aber so, damit man das noch einmal sehen kann,
dass man es auch machen kann.
Genau, das gleiche Verfahren. Erstmal kommt genau das raus,
was hier auch auf der rechten Seite steht und dann setzt
man eben dieses N durch drei hier ein, überall,
wo N steht und dann hat man hier eben N
durch neun und hier hat man dann drei durch
Und dann klammert man wieder aus. Und rechnet das halt
immer weiter, so, immer weiter einsetzen und abwickeln.
Kann man auch schon ahnen, was rauskommt,
3 hoch 0, 3 hoch 2, 3 hoch
4. Wenn man sich jetzt unsicher ist,
dann rechnet man noch den nächsten aus, wo man vielleicht nicht genau weiß,
kommt als nächstes 3 hoch 6 oder kommt als nächstes 3 hoch 8.
Vielleicht hört man das System schon erkannt, so während man
die einzelnen Schritte ausgerechnet hat und wenn man sich nicht sicher ist,
dann macht man halt noch einen weiter oder so.
Und sonst gelangt man eben irgendwie zu der Gleichung
da und muss dann eben aber wieder beweisen,
dass das richtig ist
Und da wird es jetzt schwerer zu bestimmen hier, wann wird hier abgebrochen.
Das bricht ja auch ab, wenn das Argument eins ist.
Da muss man hier dieses N durch 3K
eben gleich einsetzen und dann bricht das halt ab,
wenn N gleich 3 hoch K ist.
Wir wollen ja wissen, was K ist, also ziehen wir den Logarithmus zur Basis
3. Und dann wissen wir, das bricht zu diesem Zeitpunkt ab.
Dann können wir wieder irgendwie umformen und kommen zu zwei solchen Gleichungen und dann ist das auch nochmal umständlicher jetzt,
das hier zu bestimmen bezüglich dieser O-Notation,
dass man einmal sagt, naja,
wenn ich das hier alles habe,
dann ist das auf jeden Fall kleiner als C
plus ein Achtelmal
Größe? Nein, kleiner. Wo meine ich,
zehnmal N plus ein, achtel mal in, ach ja genau,
weil bei dem Tee von N halt noch eins durch acht Entel abgezogen wird.
Also ist das Tee von N kleiner als das hier.
Und es ist größer als das,
weil hier eben noch dieses N durch acht dazu addiert wird,
was eben größer ist als das, was abgezogen wird.
Also muss das irgendwie größer sein als das hier.
Aber dann ist es eben sowohl in Omega von N als
auch in O von N und da müsste dann insgesamt ein Täter von innen.
Kann man also auch machen, ist aber viel, viel umständlicher,
sieht man ja schon irgendwie als bei dem Beispiel davor.
Ergo nicht so richtig für eine Klausur geeignet,
würde man jetzt irgendwie, wenn man das in der Klausur machen würde,
würde man das abwickeln von der ersten Art machen und hier bei der zweiten Ehresmastertheorien benutzen lassen.
Da sieht dann so aus, muss man auch nicht,
also muss man jetzt nicht auswendig lernen, man sollte halt nur wissen,
dass man das für Rekurrenzen dieser Art irgendwie benutzen kann.
Also wenn im Argument irgendwie was mit Brüchen steht,
dann schlägt man es eben nach. Also wenn man irgendwie
auf so einer Rekurrenz mal stößt und man will die irgendwie ausrechnen,
dann sollte einem irgendwie einfallen, oh,
das könnte doch mit den Mastertheorien gehen und dann schlägt man das irgendwie nach.
Wenn man das jetzt benutzen sollte in der Klausur,
dann ist das geht eben,
das war die Frage,
sagte ich mir
Genau so. Ja, und was passiert hier immer,
wenn man das jetzt anwenden will, es wird immer dieses
F von N, das wird verglichen mit N-Hoch-Logorithmus zur Basis
B von A, also die beiden Funktionen werden irgendwie verglichen hier FN und N-Hoch-Logorithmus zur Basis
B von A. Und im Grunde genommen wird geguckt,
welches von beiden größer ist und das T von N
verhält sich dann so wie das Größere, so grob.
Weil hier sieht man F von N ist kleiner als er noch Log BR,
also er noch Log BR ist größer,
also verhält sich das T von NBN hoch Log BR.
Hier sieht man irgendwie das F von Ende ist das Größere,
weil es in den Omega davon ist,
also verhält sich das Telefon N wie das F von
Und hier ist der Fall, dass sie beide gleich sind. Und in dem speziellen Fall,
nach der Merkhilfe würde man jetzt sagen, oh,
dann ist es halt genauso groß wie eins davon,
sind ja eh gleich,
aber da kommt eben noch dieser Faktor Lugarithmisch,
dieser Lugarithmische Faktor rein und hier unten gibt es noch irgendwie diese zusätzliche Bedingung,
die man prüfen müsste.
Aber so grob vergleicht man eben F von N mit N-Hochlock BA.
Ja, genau, da kommt auch nochmal dieses Beispiel,
hier ist die Rekurrenzgleichung aus dem Mastertheorie,
hier ist die von der Aufgabe, die wir eben schon gerechnet haben.
Und da muss man eben gucken,
das B ist hier drei, das A ist auch drei,
dann ist Lugarithmus zu Basis 3 von 3-1,
F von N ist 1 durch N,
also vergleicht man irgendwie das 1 durch N mit Hoch 1 minus Ypsilon.
Das kriegt man irgendwie hinzuzeigen, dass eins durch NNO von N-Hoch 1
minus Ypsilon ist und nicht der erste Fall vor.
Und dann darf man eben, gut, dann darf man
dem Schlussfolger das T von N in N-Hoch-LogBR ist.
Und da Enno LogBR hier N-O-1 ist, ist es dann ein Täter von N.
Genauso wie das, was wir auch beim Abwickeln rausgekriegt haben,
nur deutlich schneller, muss man mal einsetzen, rechnen, fertig.
Genau, und auch da gibt es jetzt beliebig viele Aufgabentypen.
Da kann man irgendwie an dem A,
an dem B und an dem F von N spielen
und kriegt dann irgendwie immer beliebige Aufgaben dazu.
Wenn ihr euch selbst dazu Aufgaben überlegen wollt, geht das relativ schnell.
Da nehmt ihr irgendwie eine Zahl zwischen 1 bis 10
von für A für B und irgendwie eine euch bekannte Funktion
für F von N und dann ist gut,
dann habt ihr
eine Aufgabe dafür
Jo. Genau, da nochmal der Hinweis, es ist
nicht immer einsetzbar, zum Beispiel, weil der hier nicht.
Ja, dann fällt das irgendwie entweder zwischen die erste und zweite
Kategorie oder zwischen die zweite und dritte Kategorie oder bei der dritten
ist halt diese Bedingung nicht anwendbar.
Fragen dazu. Und auch da können wir wieder diese Laufzeitanalyse machen,
gegeben so ein Stück Source-Code,
wo irgendwie eine Methode mehrfach rekursiv aufgerufen wird und dann soll
man die Rekurrenzgleichen dazu aufstellen.
Bis dahin alles gut, das ist schön. Suchen und sortieren.
Erstmal das Problem so, das kennen wir alle schon,
gegeben so eine Sequenz von Entzahlen oder eigentlich von Ending,
auf die man irgendwie eine Ordnung hat, sodass man die überhaupt sortieren kann.
Wir machen das halt meistens mit Zahlen, aber eigentlich sollen es Endinge sein.
Und dann hier wichtig, es gab diese Begriffe irgendwie,
was ist stabil und was ist in place, in place,
ich brauche keinen zusätzlichen Speicherbedarf, also O von 1, viel Speicherbedarf,
klar darf ich irgendwo ein paar mit ein paar konstant vielen temporieren Variablen arbeiten,
aber ich gucke halt nicht das ganze Arry einmal oder irgendwie sowas,
dann ist es in place.
Und stabil, wenn eben zwei Elemente,
die ihr gleich sind, wenn die vorher irgendwie,
wenn vorher das AIT-Element vor dem AJten-Element kam,
dann soll es in der sortierten Reihenfolge weiterhin vor dem anderen kommen.
Das braucht man meistens, wenn man irgendwie mehrfach sortieren will,
also einmal nach Nachnamen, einmal nach Vornamen oder irgendwie sowas,
dass man das nicht wieder kaputt macht.
Genau, kurzer Exkurs zu diesen ganzen Datentypen und Datenstrukturen,
die wir bis dato hatten, weil wir ja für dieses Sortieren,
jetzt nicht nur Arys sortiert haben,
sondern nachher auch so mit Heeps gekommen sind und so.
Deswegen einmal dieser Einschub mit den Datentypen und Datenstrukturen,
hatten wir da elementare Datentypen und strukturierte Datentypen.
Das ist relativ einfach. Kennt ihr auch sowas? Ja,
Java und anderen Programmiersprachenden, elementare Datentypen einfach irgendwie, der Wertebereich,
den die so haben, plus ein bisschen Operationen da drauf und
strukturierte Datentypen geben dann eben irgendwie eine Ordnung auf diesen Elementen irgendwie vor.
Was man dann haben will bei den Datenstrukturen, ist eben,
dass man die ganzen Sachen noch in einer gewissen Struktur anordnet,
wieder mit irgendwie Methoden, die Zugriff darauf ermöglichen.
Und wenn man möchte, kann man so ein Array hier
auch schon als irgendwie eine Datenstruktur ansehen.
Die gibt irgendwie vor,
dass jedes Element mit seinem linken und rechten Nachbarn vielleicht in
der Verbindung steht und hat halt irgendwie direkten Zugriff auf alles
Genau, dann hatten wir Stackcue, Bäume und verkettete Listen,
so als erstes, bis dann eben der Heep kam.
Naja, und Stack so, ne, was sollte man wissen?
Zugriff ist Last in first out, ne, es wird irgendwie immer obendrauf gelegt.
Und dann hatten wir zwei Implementierungen uns angeguckt,
einmal sequenziell mit dem Arry und einem mit einer verketteten Liste.
Sequenziell problematisch bei Größenänderungen, ist klar, wenn ihr irgendwie,
dass Ary nur für 100 Elemente Platz habt und es kommen irgendwie plötzlich 101 oder 203 Elemente,
dann müsst ihr irgendwie das Arry vergrößern,
muss bei Arys ja nicht so unproblematisch ist,
bei einer verketteten Liste geht das.
Dafür habt ihr bei einer verketteten Liste keinen direkten Zugriff auf
die Elemente
Q, so ähnlich wie dieser Stack,
nur dass wir jetzt haben, first in first out,
Implementierung wieder sequenziell im Arry oder mit einer verketteten Liste.
Genau. Typische Fragen dazu, wenn man jetzt irgendwas zu Datenstrukturen fragen will,
was ist denn so der Unterschied zwischen der Q und
einem Stack und nennen Sie mal jeweils ein Verfahren,
das auf einer dieser Datenstrukturen beruht.
Dann sagt man, naja, Stacklast in first out Q,
first in first out und Stack und Q sind ja
irgendwie ganz prominent bei Tiefen und Breitensuche,
weil das eine benutzt bei der Tiefensuche das andere bei
der Breitensuche,
Oder dass man irgendwie so ein Stück Source-Code gibt, dass man jetzt nicht nur macht,
irgendwie VI gleich 1 bis Ende und dann passiert da irgendwas.
Und dann sagt man, oh, das ist ein O von N,
sondern dass dann da im Rumpf eben beispielsweise diese DQ- oder NQ-Methode mehrfach aufgerufen wird.
Und da muss man sich irgendwie überlegen, oh,
welche Laufzeit hatte die denn und was ergibt sich dann?
Wenn ich jetzt irgendwie en mal die NQ-Methode aufrufe und die Warteschlange ist vielleicht nicht besonders clever implementiert,
sondern irgendwie nur als verkettete Liste, dann weiß ich,
naja, wenn ich da was anhängen will,
dann muss ich immer durch die ganze Liste einmal durchgehen,
wenn ich keinen Zeige auf das Ende habe.
Und dann dauert das eben
dementsprechend lange
Sowas kann man sich angucken. Listen, kennt ihr auch,
hatten wir als einfach verkettet oder doppelt verkettet. Implementierung,
entweder wieder mit dem Array oder mit einer verketteten Speicherung.
Das ist so das, was man üblicherweise früher gemacht hat.
Problem langsamer Zugriff, aber man kann das schnell einfügen und löschen.
Und zuletzt die Bäume mit den ganzen Begriffen hier Knoten,
Vorgänger, Nachfolger, Wurzel, innerer Knotenblatthöhe,
Blattkommahöhe,
tiefe Ebene
Und so weiter. Und dann stand speziell dieser Binärbaum,
weil wir den auch gleich brauchen bei den Suchbäumen,
Binärbaum, jeder Knoten hat irgendwie maximal zwei Kinder.
Oder bei, wenn es jetzt ein Vorschlägebindierbaum ist,
der hat ja immer genau zwei Kinder und dann kann man eben so sagen,
okay, Anzahl Knoten auf eben die I sind zwei Hochi,
Anzahl Blatters zwei Hochhaar und dann kann man dann wieder Anzahl der Knoten ausrechnen und so.
Und das Spannende beim Binärbaum ist eben,
wenn er jetzt vollständig ist,
dann kann ich eben diese zwei Hochhaar plus eins,
minus eins Knoten speichern,
aber auf dem Pfad von der Wurzel zum Blatt
brauche ich eben nur lugorithmisch
viele Schritte
Deswegen auch dieses Suchen nachher mit binären Suchbäumen implementiert,
weil man da eben versucht, das,
was man vom Benieren suchen auf Arris kennt, irgendwie zu übertragen.
Dass man dann immer nur lugorithmisch viele Schritte braucht.
Klappt nicht ganz bei Benären Suchbäumen, aber so von der Idee her.
Genau, das war es dazu auch schon.
Also was hatten wir da jetzt? Stack Queue, verkettete
Listen und Bäume. Nur die Grafen kommen nachher nochmal,
die hatten wir auch schon bei der Vorlesung zu Datenstrukturen,
die kommen nachher nochmal, wenn wir bei Grafen sind.
Weiter bei dem Suchen und Sortieren,
das waren die ganzen Sortierverfahren, die wir so hatten.
Bei der anfälligen Bemerkung, Eingabe,
Ausgabe, Laufzeit, grob die Idee,
ungefährer Ablauf
Boah, um meine Stimme zu schonen. Was ist denn die Idee bei Quicksord?
Also Aufgabentext, beschreiben Sie mal die Idee von Quicksord.
Ich habe eine Menge von Elementen und mich teilen sehen an
einem bestimmten Element, dass ich das gute Team auswähle.
Und dann sage ich, welche Er weckt ihn über.
Er liebt ihn euch, das ist immer gestimmt worden,
als wenn ich dieses Apatrikot wieder teile. Genau,
jetzt kann man noch tiefer reingehen, das war richtig,
jetzt kannst du noch tiefer reingehen und noch erzählen,
wie das passiert mit dem Aufteilen.
Also erstmal könntest du das Ding noch Pivo-Element nennen,
dieses spezielle Element. Das wählst du so, genau,
und jetzt links sollen die sein, die kleiner sind,
rechts sollen die sein, die größer sind.
Das war dir wahrscheinlich implizit klar,
aber so, und wie passiert das jetzt?
Wie macht man das? Dass quasi dieses Partitioning da,
ne?
Ja, fast
Ja, geht so, ne, also wir hatten das so gemacht,
dass wir als Pivolement einfach das am weitesten rechts genommen haben
, so das vereinfacht jetzt ein bisschen das Weitere,
wenn wir das nehmen, dann ist alles,
was links davon steht, ist jetzt das, was wir sortieren wollen.
Und dann geben wir das ja gleichzeitig von links und rechts durch und gucken immer,
ob irgendwie, wenn das kleiner ist,
das ist ja alles Gute, machen wir weiter,
du bist für ein Element, finden das größer als das Pivo-Element.
Hier machen wir das genauso, bis für ein Element,
finden das Kleines als das Pivo-Element,
wenn wir das gemacht haben, swappen wir.
Und dann machen wir weiter. Und irgendwann schieben wir das Pivo-Element
genau an die richtige Stelle, so nochmal die Mitte da setzen,
dann ist gut.
So, es gibt ja nur, also wir gehen mal kurz davon aus,
dass wir, dass alle Elemente da drin unterschiedlich sind.
Und dann gibt es ja nur,
entweder sind Elemente kleine oder sie sind größer. So,
jetzt komme ich mit so einem Arry von zehn Zahlen,
die erst die Zahl ganz rechts, das ist mein Pivotlimit.
Jetzt habe ich noch neun Zahlen. Und für jede Zahl
da drin gilt, die ist entweder klein oder größer.
Jetzt kann ich ja von links durchgehen und suchen, bis ich ein größeres Element finde.
Das hat ja nichts mit Sortiertsein zu tun. Da kann ja kommen,
wenn das Pivot Element 10 ist, dann könnt ihr jetzt kommen,
8, 2, 5, 1,
das ist ganz bestimmt nicht sortiert, aber die sind alle kleiner.
Und das reicht mir. Und hier suche ich halt,
bis ich eins finde,
das kleiner ist
Und wenn ich das schaffe, dann weiß ich,
also alles, was jetzt links ist, ist klein,
ist das Bigo-Element, alles ist rechts,
es ist größer als das Bigo-Element und hier finde ich jetzt das erste Mal Elemente,
die dem widersprechen und die beiden tausche ich.
Und dann ist es bis zu diesem Punkt schon, okay,
und dann mache ich weiter. Und nach einer Ausführung von,
also wenn man das jetzt, wenn man noch nicht rekursiv abgestiegen ist,
sondern jetzt hat man das einmal gemacht, das einzige Element,
was jetzt an der richtigen Stelle ist, das Pivo-Element.
Also die anderen vielleicht auch,
aber eigentlich ist erstmal nur das Pivo-Element an der richtigen Stelle.
Das ist sehr schön bei Quickshot, ne? Also das ist ein Sortieralgorithmus,
der guckt sich alles schon einmal an und das einzige Element,
was dann nach End-Operation an die richtige Stelle gesetzt hat,
ist das blöde Pivo-Element,
alle anderen Bimmeln noch rum so,
Aber genau, so das macht Quicksort, Heepsort sehen wir gleich noch.
Jetzt kann man einmal durchgehen hier, boah,
Laufzeit, Insertions, sort mit Maxsort, Bubblesort,
alle in U von Endquadrat, Merchsort U von N mal Login,
Quicksort, wieder ein U von Endquadrat,
wenn man Worst Case Laufzeit machen will.
Heeps hout U von N mal Login,
Counting Sort U von N, aber arbeitet nicht mehr vergleichbarsiert.
Also kommt dann nur noch mit Zahlen klar und so und
ist dafür aber schneller, arbeitet in diesem U von N.
Und dann hatten wir hier noch irgendwie Relixsort und Bucket Sort,
aber die sind nicht so wichtig
Eins, zwei, drei, vier, fünf, sechs,
sieben, genau. Also sieben, sieben Sachen hatten wir.
Was man dann noch wissen kann, wenn man möchte,
sind so Sachen wie, welche davon sind stabil,
welche davon sind Inplays, solche Geschichten.
Genau. Vergleichen, nicht vergleichend, hatten wir gerade untere Schranken für
das vergleichende Sortieren, untere Schranke, Omega von Annema Login.
Das heißt, sowas wie Merch Sword ist optimal.
Merch Sword und Heep Sword. Zumindest asymptotisch optimal. Ja,
und jetzt das große Thema Heeps. Da ist die ganze textuelle Erklärung,
aber da, dass wir den gleich nochmal sehen,
die Idee bei so einem Heep war eben,
wenn man sich irgendeinen Teilbaum raussucht, Dann ist die Wurzel immer das größte Element.
Und alles da drunter ist kleiner. Und das war die
einzige Bedingung. Also es muss jetzt nicht so sein,
dass irgendwie das, was wir nachher beim Binären Suchbaum haben,
dass alles, was links ist, kleiner ist und alles,
was rechts ist, größer, sondern der Hieb sagt einfach nur,
nimm einen Teilbaum, die Wurzel ist das größte Element.
Also der Baum ist auf allen Ebenen vollständig gefüllt,
außer möglicherweise auf der letzten,
wird durch ein Arry repräsentiert und eben bei der Maxi-Eigenschaft
der Vater ist immer größer als seine Kinder
Und dann kommt man eben hier mit diesen Operationen
immer schön an die Kinder oder an den Vater ran,
was hier in so einem Arry ist.
Wenn man bei der 8 ist,
dann ist das linke Kind eben zweimal dem Inde,
zweimal der Index und das rechte Kind ist zweimal der Index plus 1.
Und wenn man irgendwie bei so einem Kind ist,
dann kann man einfach halbieren und gegebenenfalls abrunden und dann ist man beim Vater.
Deswegen ist diese Arry-Darstellung ganz schick. Und wenn man so
einen Baum in Arry übertragen will oder andersrum,
dann geht man das eben von oben nach unten und Ebene für Ebene durch.
Also 16, 12, 15, 11, 8,
7, 13, 7, 6, 1,
2, 4,
5,
Genau, und jetzt war die Idee, dass man sowohl
sortieren damit kann, als auch diese Warteschlangen-Operationen machen kann.
Und wenn man eben sortiert damit, dann macht man zuerst diese Bild-Maxi-Eigenschaft.
Also ich gebe euch irgendwie ein Array von Zahlen,
dann wird darauf Bild maxib aufgerufen.
Und dann wird damit eben Schritt für Schritt der maxib aufgesetzt,
wobei man da eben diese Maxi-Bify-Operation braucht.
Und wenn man das gemacht hat,
dann kann man danach ganz einfach mit Heepshot das Array sortieren.
Weiß noch einer, wie die Maxi-Bify-Operation funktioniert,
also was war da das Ziel?
Oder auch Bildmaxib, kommt das gleich hinaus
Was war schlecht, was hat er denn gestört? Na,
Vorsortieren ist doof, ich brauche ja nicht sortieren, wenn ich vorsortiere.
Genau, dass die Maxibi-Feier-Operation, also ich habe einen Knoten,
von dem ich noch nicht weiß, aber die Hippie-Feier,
aber die Hieb-Operation, die Hieb-Eigenschaft erfüllt.
Sprich, der ist vielleicht nicht der Größte. So,
jetzt gucke ich, ob der größer ist und alles andere da drunter weiß ich aber,
das erfüllt schon die Hieb-Eigenschaft. Und jetzt,
wenn das Also wenn beispielsweise das hier keine 15 ist,
sondern zehn, so,
dann rufe ich auf dem halt die Maxipify-Operationen auf und dann stelle ich fest,
oh, zehn ist ja gar nicht größer als seine beiden Kinder,
13 ist nämlich größer, also tausche ich das mit der 13 aus.
Ja, und danach ist die 13 da oben und die zehn ist da,
wo die 13 ist und dann gucke ich weiter,
ist zehn größer als neun, ja, ist es,
also kann ich aufhören.
Sprich, bei der Maxipify-Operation lasse ich so eine,
so einen Knoten so weit absinken,
bis die Hieb-Eigenschaft wieder gesichert ist.
Sprich, bis er größer ist als seine beiden Kinder.
Und wenn ich jetzt ein Bild Maxib machen will,
dann kriege ich irgendwie so ein Arry von Zahlen
Dann male ich mir da Ebene für Ebene und von links nach rechts irgendwie den Baum auf,
der ist dann ja noch kein Hieb,
aber ich baue mir den Baum auf und dann fange ich quasi bei der,
naja,
bei der ersten Ebene von unten gezählt an und rufe auf die ganzen Knoten immer diese Maxipify-Operationen auf.
Auf die brauche ich das noch nicht aufrufen, oh,
jetzt wird rosa. Auf die brauche ich das,
das liegt an meiner Stimme. Morgen. So und plötzlich
kommt da so eine Anonymus-Maske, das wäre jetzt cool.
Wir übernehmen diese Veranstaltung
So, darf ich wieder? Liebes Beamer-Dings? Ich guck gleich,
wir machen irgendwie, wir müssen eh gleich kurz Pause machen.
Also die unterste Ebene ist ja schon sortiert,
oder die unterste Ebene erfüllt die Maxi-Eigenschaft hier,
weil die haben ja keine Kinder.
Also fange ich bei den Knoten an hier.
Und wenn die halt noch nicht die Maxi-Eigenschaft erfüllen,
dann rufe ich auf all die Maxi-Bify auf.
Und dann wandern die Knoten halt nach unten, gegebenenfalls.
Und danach ist für die ganze Ebene die Hieb-Eigenschaft erfüllt,
also für all die Bäume, die da drunter kommen.
Und dann mache ich hier weiter und dann
mache ich auf der letzten Ebene weiter und irgendwann habe ich
einen kompletten Hieb
Und da habe ich Bildmaxib aufgerufen und bei dem Heep,
bei dem Heepshord, da weiß ich ja jetzt,
die Wurzel hier oben ist das größte Element.
Das sagt mir ja die Heep-Eigenschaft. Also nehme ich das,
packe das ganz nach hinten in meinen Ausgabe Arry.
Dann nehme ich mir hier rechts unten das Element,
packe das da oben hin und rufe darauf die Maxibify-Operationen auf.
Dann wandert das wieder nach unten. Und dann ist wieder
das größte Element oben, dann nehme ich das wieder,
tue das an, die vorsätze Stelle, in dem Arry.
Dann nehme ich wieder so ein Element da irgendwo von den Blättern,
setzt das nach oben, ruft die Maxibify-Operation auf und so weiter.
So funktioniert halt dieses Heepshord, das Bild Maxib und
das Maxibify
Genau. Bei den Warteschlagen, hieb Maximum ist klar,
da nehme ich einfach die Wurzel, hieb Expect Max genauso,
also hier bei hieb Maximum liefere ich halt den Wert der Wurzel zurück,
löscht die Wurzel aber nicht, bei dem Hieb Extract Max,
da würde ich halt die Wurzel extrahieren.
Bei den Warteschlagen will man das ja immer haben, so man möchte gucken können,
welchen Wert hast du gerade oder möchte sie auch rausnehmen können. Genau,
das hier, dieses Hieb Extract Max, nutzt wieder Maxhibify,
weil man im Grunde genommen das Gleiche macht,
wie bei den Hieb Salt, ich nehme die Wurzel,
schmeiße sie weg oder mache irgendwas damit und nehme ich mir so ein Blatt,
tue das da oben hin und worauf einmal die Maxhibify-Operation auf.
Und dann gab es noch diese Heep and Crease Key und
Heep Insert da konnte man halt irgendwie hier so einen Knoten,
da nehme ich mir von mir jetzt hier die vier und
setze das auf 15,5 und dann ruft man auf die im Grunde genommen so eine Umkehrung von dem Maxipify auf.
Den guckt man nämlich immer,
bin ich größer als mein Vaterknoten und falls ja,
dann bin ich auch größer als mein Nachbar hier,
also tauschen die beiden. Und dann gucke ich wieder,
bin ich größer als mein Vaterknoten und falls ja,
tauschen die beiden und irgendwann hört das auf.
Also entweder bin ich irgendwann bei der Wurzel angelangt oder ich bin
nicht mehr größer als mein Vater und dann bin ich an der richtigen Stelle.
Das ist halt das, was hier so passiert.
Genau, das ist das zu Heeps und so,
da steht nochmal die Zusammenfassung auch bezüglich der Laufzeiten
Maxibifice korrekt, hat eine Laufzeit von O von Login,
Täter-Login. Bild Maxib, diese O von Enma Login,
weil ich ja eng mal die Maxibifice-Operation aufrufe,
die Maxibifice-Operation ist in Login, also ist das in O von Enma Login.
Und wenn man das genauer analysiert, dann kommt man halt
darauf, dass das sogar ein Täter von Ende ist.
Das hängt halt damit zusammen, dass die ersten Dinge,
auf die ich diese Maxibifice-Operation aufrufe,
ja maximal eine Tauschoperation haben und nicht bis zu Login vielen.
Kann man das alles aufaddieren und dann kommt man dahin,
dass man gar nicht so viele Schritte braucht hier,
dass das zwar der obere Schrank ist, aber keine,
die besonders exakt ist und O von Ende ist halt
viel schicker
Oder Täter von denen ist es dann sogar. Genau,
und dann Heepsword, Täter von Annema Login,
also auch wieder optimal asymptotisch, weil wir ja vergleichen,
das Sortieren hier wieder haben und da die untere Schranke eben
Omega von Annema Login ist, sortiert auch Inplays.
Ich habe ja nur das Area, auf dem ich irgendwie rumoperiere,
also ich brauche kein zusätzliches Area, wunderschön.
Und hier nochmal die Operation für die Warteschlangen und wie da die Laufzeit ist.
Genau, und bevor wir zum Suchproblem kommen, möchtest du?
Ja. Christiane wollte nochmal eine Umfrage machen zu,
willst du selbst erzählen
Nö. Christiane möchte noch mal eine Umfrage machen,
um das noch mal zu Ende zu evaluieren,
was wir bei Aufgaben Blatt 4 so gemacht haben.
Und ich gucke mal währenddessen,
ob ich den rosa Stich aus den Folie hinkriege.
Mal gucken. Das dauert so fünf bis zehn Minuten
so grob. Zehn. Okay. Ich weiß nicht.
Der Livestream läuft einfach weiter. Das ist okay.
Lieber Livestream. So. Na, wir brauchen noch Zeit.
Na, wie weit seid ihr?
Seid ihr durch? Ja, geil. Da gibt es
mal was
Untertitel der Amara.org Oh, wollen wir? So,
die beiden gehen jetzt rum und sammeln ein und ich erzähle
mir einfach weiter.
Okay,
das Suchproblem
Mhm. Ja, ja, klar. Das ist die
Welt. So, groß. Fußball. Da, da
. So. Gleicher. Machen wir gleich dann in dem.
So, wir müssen weitermachen. Mein Screensafe ist angegangen
Es war jetzt lang genug. Für die Verschwörungstheoretiker unter euch,
habt ihr darauf geachtet, es gab genau 23 Fragen.
Und damit es, ja genau, damit das nicht auffällt,
gab es einmal die Eins am Ende.
Denkt ihr was dazu? Warum war das so?
Und gleichzeitig habe ich eine Folie 42 aufgehört.
So. Ach ja, genau. Die Abgaben noch von Blatt
4. Wer gleich noch Blatt 4 abgeben möchte,
das machen wir gleich in der Pause.
Dann könnt ihr mir das in der Pause vorne hier hinlegen
und dann haben wir die auch.
Also wer die gleich noch abgeben möchte,
wäre schön,
freuen wir uns
Und genau, dann geht mir das gleich einfach nach vorne. So,
um weiterzumachen, das Suchproblem, also wir hatten jetzt Sortieren
mit den ganzen Sortieralgorithmen und vor allem diesem Heepsword und Suchproblemen.
Ursprünglich kamen wir auch über das Suchproblem zum Sortieren,
weil wir irgendwie festgestellt haben, lineares Suchen dauert o von Enfield-Zeit,
binäres Suchen geht in o von Enmalo,
er geht in o von Login.
Schön, dafür muss es aber sortiert sein.
Also hat man gesagt, naja gut,
dann sortieren wir vorher und dann geht das Suchen schön schnell.
Wenn man denn irgendwie weiß, man will ganz,
ganz oft Dinge suchen, dann ist das praktisch,
wenn man das vorher sortiert hat.
Allgemein ist das Suchproblem irgendwie eine gegebene Menge und irgendwie einen
Wert und dann suche ich irgendwie einen Zeiger auf dieses Element
mit dem WRK
Also es muss nicht immer ein Arry sein. Und
wenn man jetzt die Idee vom Binären suchen verallgemeinern will,
dann kommt man irgendwie zu diesen wie näheren Suchbäumen.
Die haben vor allem auch den Vorteil, dass es eine
dynamische Datenstruktur ist, sprich die kann wachsen und schrumpfen.
Anders als Arys. Genau. Und die,
so ähnlich wie ein Hieb, auch wieder ein Baum,
aber hier ist es jetzt so, ich habe einen Knoten und links,
alles was links von diesem Knoten ist, ist kleiner,
alles was rechts von dem Knoten ist,
ist größer
Hier als Beispiel, die zehn und alles, was links ist,
könnt ihr sehen, ist alles kleiner als zehn.
Alles, was rechts ist, ist größer als zehn.
Und das Problem ist, man kann das hier vielleicht schon so
ein bisschen erahnen an diesen einzelnen Zweigen, der kann halt komplett entarten.
Also das kann nachher sowas werden, so eins,
zwei, drei, vier, fünf, sechs,
sieben, acht, neun, zehn.
Dann hat man da gar nichts von. Schön ist,
wenn der möglichst ausgeglichen ist, beim Binären Suchbaum,
kriegt man das nicht per se hin, dass der ausgeglichen ist.
Der sieht halt einfach irgendwie aus. Deswegen sind die Worst Case
Laufzeiten nicht so schick. Und dann gibt es halt Ansätze,
wie man das machen kann, dass der Baum nach Möglichkeit
immer ausgeglichen ist.
Stichwort Rot,
Schwarzbäume und AVL-Bäume
Genau, also da waren die wichtigen Operationen, die wir so haben wollten,
einfügen, löschen, Minimum, Maximum und suchen. Und hier war halt die Idee,
wenn ich jetzt irgendwie ein Element suche,
dann gucke ich halt einfach immer,
ist das Element kleiner oder größer als die Wurzel,
wenn es kleiner ist,
suche ich in dem Baum links weiter,
wenn es größer ist,
suche ich in dem Baum rechts weiter und dann vergleiche ich da wieder mit der jetzt neuen Wurzel und gehe dann in den linken oder rechten Teilbaum, je nachdem.
Also das Suchen ging relativ einfach. Einfügen ging auch einfach,
da mache ich zuerst das Gleiche wie beim Suchen,
bis ich halt an der Position von so einem Blatt angekommen
bin und dann füge ich das entweder links oder rechts ein
Löschen ging einfach, wenn es ein Blatt ist,
dann lösche ich das einfach oder wenn es genau einen Nachfolger gibt,
so wie hier bei der 15, dann lösche ich das auch und mache einfach die 16 zum Kind von 14.
Das einzige Problem war, wenn ich etwas lösche, was zwei Kinder hat,
wenn ich jetzt zum Beispiel hier die sechs löschen will oder auch hier,
nehmen wir mal die zehn,
welche Zehen löschen will und dann mache ich das so,
dass sich dann, wer weiß es noch,
was mache ich, wenn ich binären Suchbaum etwas lösche,
was zwei Kinder hat?
Genau. Gut an. Ja, genau. Ich suche
den direkten Nachfolger, das heißt, der direkte Nachfolger,
größte, ja, die kleinste Zahl im rechten Teilbaum.
Also gehe ich in den rechten Teilbaum und suche da das Element,
was am weitesten Link steht. Und hier würde ich jetzt
in den Teilbaum mit der Wurzel 14 gehen, das Element,
was da am weitesten Link steht, ist die zwölf.
Die nehme ich also, weil die am weitesten Link steht,
hat die kein linkes Kind mehr. Also hat die nur
noch ein Kind maximal. Also kann ich die Nehmen ausschneiden,
weil dann die 13 ja nach oben und einfach da einsetzen,
wo die zehn ist. Wenn ihr das mal macht,
wenn ihr da, wo die Zähne ist, die zwölf hinsetzt,
dann seht ihr, dass ihr wieder einen Bienensuchbaum habt.
Alles, was rechts ist, ist größer, alles,
was links ist, ist kleiner.
Genau, das ist das Löschen
Minimum, Maximum, Minimum halt,
dass sie damit was ganz links ist, Maximum,
das Element, was ganz rechts ist.
Success haben wir eben gemacht, Vorgänger ist so ähnlich,
nur dass man eben das Element sucht,
was im linken Timebaum weitest und rechts steht.
Die Lied haben wir gemacht, Einfügen haben wir gemacht,
suchen auch. Genau, und hier halt nochmal die Anmerkung.
Bei Minimum suchbar mit Endknoten der Höhe Haar ist das halt hier
die anderen Operationen, sind alle in O von Haaren.
Ist zwar gut, wenn der ausgeglichen ist,
dann ist das irgendwie ungefähr ein Login,
aber im Worst Case ist das
eben in O
Auftritt rot-Schwarzbäume, kurzer Exkurs. Da versucht man ihm sicherzustellen oder das erreicht man da auch,
dass die balanciert sind und dass dann eben die Worst-Case-Laufzeiten von den eben genannten Operationen,
also löschende Einfügen und so weiter,
dass die ein O von Lock-in sind.
Da muss man halt sicherstellen, dass die so rot-Schwarzeigenschaft immer sichergestellt ist,
sprich man reichert diesen vinären Suchbaum noch um zusätzliche Eigenschaften an,
vor allem eben um diese Farben rot und schwarz.
Jeder Knoten hat noch eine Farbe und dann wird eben gesagt,
wenn ein Knoten rot ist,
dann müssen beide Kinder schwarz sein und egal bei welchem Knoten ich starte,
alle Pfade von diesem Knoten zu einem Blatt haben
die gleiche Anzahl der schwarzen Knoten
Man sieht das irgendwie so aus, oder das ist jetzt ein Beispiel für einen Rot-Schwarzbaum, der korrekt gefärbt ist. Genau,
und dann kann man sich überlegen, jetzt muss man irgendwie aufpassen,
wie mache ich das mit dem Löschen,
wie mache ich das mit dem Einfügen,
also wenn ich jetzt irgendwie hier die zwölf Lösche und die 13 dann nach oben schiebe,
dann stimmt irgendwie nicht mehr,
dass auf allen Faden gleich viele schwarze Knoten sind,
weil ich dann habe hier 10, 14,
13 und hier habe ich 10, 14, 15,
16, dann sind da bei dem zuletzt genannten Drei-Schwarz-Knoten,
bei dem anderen nur noch zwei,
also muss ich irgendwie noch Dinge anders tun.
Aber was man dann eben hinkriegt, hier dritter Punkt,
dass das tatsächlich alles in O von Login ist,
oder hier beim vierten Punkt, Aber das nur einmal kurzer als Exkurs,
das brauchen wir nicht für die Prüfung,
aber dass ihr halt nochmal wisst, okay,
binäre Suchbäume sind zwar schick.
Ich kann da auch, sieht so aus,
als könnte ich da schnell suchen, schnell löschen und so weiter.
Aber ich habe eben das Problem,
dass ich unter Umständen doch in O von N bin.
Worst Case, wenn er nicht balanciert ist. Deswegen gibt es
eben Ansätze, wie man solche wenigen Suchbäume balancieren kann,
indem man die irgendwie mit zusätzlichen Infos anreichert.
In dem Fall ja nur mit sehr wenig Infos.
Also eigentlich brauche ich nur so einen Witfleck,
ist das Gesetz, ist das schwarz, ist es nicht Gesetz,
ist er rot oder irgendwie sowas.
Also viel Speicher verballere ich da nicht. Aber ich muss
dann eben nachher bei den Operationen deutlich mehr Grips reinstecken,
damit die funktionieren
Ja, das war es zu suchen und sortieren.
Fragen bis dahin. Ach so, typische, typische Klausuraufgaben, ja. Nee,
wie gesagt, Rotschwarzbäume war jetzt so ein Exkurs,
nur dass ihr wisst so,
es gibt diese Rot-Schwarzbäume und man kann binäre Suchbäume halt quasi aufpeppen,
um sie zu balancieren.
Also wie gesagt, die sind jetzt nicht klausurrelevant.
Wir sind jetzt nur so, dass ihr es nochmal gesehen
habt, auch in der Zusammenfassung.
Genau, und typische Klausuraufgaben werden jetzt sowas gegeben wie
näherer Suchbaum
Löschen Sie die 17, wie sieht jetzt der binäre Suchbaum aus? Zeichen Sie denen? Oder gegeben,
ein Array, wie sieht denn der Zugehörige Hieb aus,
dass man das einfach mal so Ebene für Ebene aufmalt und dann eben so fragen,
wie, was passiert denn, wenn ich da jetzt die Maxi-Befrei-Operation aufrufe,
gegeben der Heeps-Hord-Algorithmus zu einem bestimmten Zeitschritt so und dann wird gesagt,
so was passiert jetzt als nächstes ohne,
jetzt nehme ich das Element da, rechts unten,
was bisher noch nicht bearbeitet wurde, setzt das nach oben und so weiter,
dass man das irgendwie sagen kann oder ausführen kann.
Genau, oder halt so irgendwie Wissensfragen zu den Laufzeiten,
vielleicht so ein bisschen Oder, ne,
beschreiben Sie Vor- und Nachteile von binären Suchbäumen, dass man dann irgendwie weiß,
naja, wie die ihre Suchbäume versuchen halt zu erreichen,
dass das alles in Ofon Log-in abläuft.
So im Normalfall mag das auch hier und da mal klappen,
aber im Worst Case eben nicht so, ne?
Ist das auch gut. Gut, Grafen,
das ganz dicke Thema, wo jetzt ganz viele Algorithmen rumflattern,
da nochmal die ganzen Begriffe, die man so irgendwie,
wo man ein Bild so haben sollte,
was man irgendwie kennen sollte, wie Kreislänge,
ich habe, glaube ich, alles.
Und dann war da die Idee,
entweder kriege ich das als so eine Art Jazenzmatrix,
wo eben so ein WX hier,
da steht genau dann der Eins,
wenn wir eben mit X verbunden ist und bei WY steht
eine Null,
weil es eben keine Kante von W
zu Y gibt
Und wenn er nicht ungerichtet ist, sondern gerichtet,
dann wird die Matrix eben nicht mehr symmetrisch.
Da als Addizenzliste, da kriegt dann jeder Knoten eine Liste
von den Knoten, mit denen er verbunden ist.
Hier ist die Speicherung in O von V-Quadrat und hier in
O von V plus E. Breitensuche hier jetzt einmal noch mit Source Code.
Am Anfang sind die alle weiß,
dann färbe ich den ersten Knoten irgendwie grau,
die Distanz für den Startknoten zum Startknoten ist halt null und
dann hier packe ich das alles in die
Oder pack den Startknut in der Q und dann tue ich
dann immer alle seine Nachbarn in die Q.
Ich nehme den Knoten aus der Q raus und jeden Nachbarn
tue ich dann in diese Q und kriege so dann eben eine Breitensuche hin,
bei dem Grafen, wenn man hier bei S angefangen hätte,
könnte das so aussehen,
dass man irgendwie am Anfang zu A und C kommt,
dann kommt man von A eben zu B und E und von C zu F.
Wenn in der Q das am Anfang so gewesen wäre,
dass nachdem man S bearbeitet hatte,
C zuerst in der Q gewesen wäre und dann A,
dann wäre eben B von C aus entdeckt worden.
Das ist weiterhin die Entfernung 2,
aber da ist so ein bisschen Naja, Wahlmöglichkeit,
in Anführungsstrichen, je nachdem,
wie der Graf gegeben ist und wie man durch die Azenzmatrix oder die Attizienzliste halt durchwandert,
können sich bei der Breitensuche da unterschiedliche Spannbäume ergeben.
Und dann arbeitet man da weiter durch. Das ist das,
was bei der Breitensuche passiert und bei der Tiefensuche,
da mal jetzt ohne Source Code,
auch wenn man hier wieder bei S anfängt,
da war das halt so,
dass man immer so mit diesen Discovery und Discovery und Finishing Times gearbeitet hat und eine Möglichkeit wäre eben,
der ist hier gewesen.
Man fängt hier an,
den entdeckt man bei 1 und dann packt man die Nachbarn
auf den Stack und dann geht man halt los,
jetzt entdeckt man den
hier bei
Den bei drei, von dem aus sieht man den Knoten S wieder,
weiß aber, oh, den habe ich schon,
also ist mal mit B fertig, dann kriegt der Abarbeitungszeit vier,
dann geht man zur A zurück, stellt fest,
bei dem hat man auch alle Kinder bearbeitet,
also kriegt er die fünf,
geht dahin zurück und von dem gibt es noch ein Kind zu bearbeiten,
nämlich den Knoten C, dann entdeckt man den zum Zeitpunkt sechs,
die Kante von C zu B braucht man auch nicht,
weil man B ja schon abgearbeitet hat,
dann kriegt er die sieben wieder einen Schritt zurück,
acht und danach entdeckt man das hier unten.
Das ist so das bei der Tiefensuche,
ist vor allem wichtig,
dass ihr irgendwie mit diesen Discovering und Finishing-Zeiten klarkommt,
weil man die halt für diese anderen Algorithmen braucht,
Stichwort topologisches Sortieren und strenge Zusammenhangskomponenten
Ja. Auch da so eine Frage irgendwie, keine Ahnung,
was Rule bei der, bei der, naiven Implementierung,
was unterscheidet Tiefensuche und Breitensuche primär bei der Implementierung.
Dann sagt man, naja, bei der Tiefensuche benutze ich
einen Stack und bei der Breitensuche benutze ich eine QU.
Also man muss jetzt nicht irgendwie sowas hier angeben,
dass man irgendwie sagt,
geben Sie mal den ganzen Code an und man gibt das da komplett an oder so,
sondern halt nur, dass man irgendwie weiß, naja,
dass man es ausführen kann, dass das irgendwie so aussieht oder eben so.
Und dass einem eben grob klar ist, was da irgendwie passiert,
dass man vielleicht auf so einer Ebene beschreiben kann,
was passiert, dass man sagt, naja,
bei der Tiefensuche fange ich bei einem Knoten an
All die Kinder tue ich dann auf dem Stack,
dann nehme ich mir das US-D-Element vom Stack,
dann noch Möglichkeit habe ich ja auch gar nicht,
tu die Kinder wieder auf den Stack und so weiter.
Oder bei der QL, dass man sagt, naja,
ich mache das mit einer, bei der breiten Suche,
ich mache das mit der Q. Genau, dann topologisches Sortieren,
basiert ja oder benutzt Tiefensuche, gegeben so ein gerichteter,
adzyklischer Graf, also keine Kreise und dann möchte ich eine topologische Sortierung haben.
Das heißt, eine Anordnung der Knoten mit der Eigenschaft,
dass in dieser Anordnung ein Knoten-U genau dann vor V liegt,
falls es eben so eine Kante UV gibt.
Idee, eine Tiefensuche machen und jeden abgearbeiteten Knoten an den Kopf einer Liste einfügen,
also in umgekehrte Reihenfolge der Abarbeitungszeiten die Knoten ausgeben.
Wenn ich das hier hatte, den hatte ich zuletzt,
der hat die zwölf, also im Knoten eh,
habe ich zuletzt die zwölf Knoten d davor, der hat die elf,
das nächst kleinere von den Abarbeitungszeiten ist die acht von S,
dann die 7 von C,
5 von A und 4 von B,
also das ist ja irgendwie das jetzt topologische Sortierung kriege.
Und von der Idee, wenn man die Dinger,
die Knoten in der Reihenfolge ausführen würde,
dann würde man halt so,
wenn man das als To-do-Abhängigkeiten hat,
das in der richtigen Reihenfolge ausführen
Dass das topologische Sortieren und strenge Zusammenhangskomponenten maximale Mengen in
dem Grafen derart oder maximale Teilmengen der Knotenmenge derart,
dass in so einer Teilmenge jeder Knoten, von jedem Knoten,
zu jedem anderen Knoten Pfad gibt.
Also wenn ich irgendwie zwei Knoten-UNV habe von so einer maximalen Menge ziehe,
dann soll ich von U zu V kommen können über irgendeine Fahrt und von V auch zu U.
Wie macht man das? Man macht eine Tiefensuche,
dann berechnet man diesen transponierten Grafen,
sprich man dreht alle Kanten um und dann macht man darauf nochmal eine Tiefensuche,
aber jetzt macht man es eben so,
dass man die Knoten nicht einfach irgendwie beliebig abarbeitet,
sondern man nimmt sie so in der Reihenfolge fallender Endarbeitungszeiten
Von dem vorherberechneten Endzeiten. Genau. Kommt da noch das Beispiel? Nee. Genau,
also gegeben so ein größerer Graph,
macht ihr einmal eine Tiefensuche, dann dreht ihr halt,
ne,
dann meint ihr den Graphen nochmal und dreht alle Kanten um und schreibt euch für mich aus in die Knoten irgendwie die Abarbeitungszeiten,
die ihr vorher ermittelt habt und entsprechend dieser Abarbeitungszeiten fangt ihr halt mit der Höchsten an und macht von dem Knoten aus eine Tiefensuche,
alles, was sie erwischt ist,
eine strenge Zusammenhangskomponente in dem ursprünglichen Graphen oder nehmt ihr von denen jetzt noch nicht bearbeiteten Knoten,
den mit der dann höchsten Abarbeitungszeit.
Und immer so weiter und dann habt ihr
die ganzen strengen Zusammenhangskomponenten
Genau, also die Ergebnisse, Topus vor Ort,
V plus eh streng Zusammenfassungskomponenten, V plus eh,
hängt halt damit zusammen, dass Tiefensuche in V plus eh
ist und das in dem Fall von den strengen Zusammenhangskomponenten nehmen dieses Transponieren auch relativ schnell geht.
Jo. Genau, dann noch den minimalen Spannbaum,
also einen Baum in einem Grafen finden,
der alle Knoten enthält und demnach eben genau V minus eins kannten und derart,
dass wenn man die Kantengewichte aufsummiert, das Ergebnis eben möglichst mit ihm alles.
Das wird gesucht, Ideen, die wir da hatten,
war einmal Kruskalsalgorithmus und einmal Primsalgorithmus Und genau, da lief das so, ne?
Kruskal nimmt unter allen, kannten jene mit dem kleinsten Gewicht,
deren Hinzufügen nicht zu einem Kreis führt. Also der hat quasi,
wenn man jetzt nur die Kanten, die er bisher genommen hat,
betrachtet immer irgendwie mehrere Inseln in den bisherigen Grafen,
die noch nicht miteinander verbunden sind und so Stück für Stück verbindet Eddie dann.
Und Prim,
der fängt quasi mit einer Insel an und die breitet sich dann immer mehr aus,
weil er von dem, was er bisher entdeckt hat,
guckt er sich jetzt alle Kanten an,
die davon weggehen zu etwas,
was er noch nicht entdeckt hat und davon nimmt er dann
die mit dem geringsten Gewicht
Genau, korrekt hat, relativ kompliziert zu zeigen,
Ausführungen, insbesondere von dem Kruskal, sehr einfach.
Beim Prim ist es auch nicht sonderlich viel schwererer,
man muss halt nur ein bisschen mehr notieren, aber ist auch nicht wild.
Genau. Da sieht man es nochmal hier, Kruskal,
die Menge A, ist ein Wald,
also wie gesagt, so einzelne Inseln.
Und bei Prim ist die Menge A immer ein einzelner Baum.
Und dann wird immer eine sichere Kante mit minimalem Gewicht hinzugefügt.
Laufzeit, Kruskal, O, Ema, Lokfau,
Prim, auch O, Ema, Lokfau.
Und kann man sogar ein bisschen schneller machen.
Aber wenn man für beide weiß,
dass die Laufzeit ja irgendwie ein O-Ebener Lokfau ist,
dann genügt das
Genau, also bei beiden wissen, wie man die ausführt, gegebenenfalls auch ein bisschen beschreiben können, wie man die ausführt und eben wissen, was die Laufzeit irgendwie ist. Ah,
genau, und dann schön zu wissen,
wenn man irgendwie den Übergang weiß von Prim zu Deixtra,
weil einem irgendwie klar ist, da extra läuft fast genauso wie Prim,
nur dass es eben diese eine Stelle geht,
wo man irgendwie rumtweaken muss,
dass man nicht einfach nur die Kante mit dem minimalen Gewicht nimmt,
also ich habe bisher was berechnet und jetzt gucke ich mir die Kanten,
die da rausführen, nicht nur die mit dem minimalen Gewicht an,
sondern ich gucke mir quasi an,
was die Summe ist von dem Knoten, die Kosten,
die ich bisher bezahlen müsste,
um zu einem Knoten zu kommen,
plus diese Kante
Da kommt ein bisschen was anderes raus.
Und dann kriege ich halt Dextras-Algorithmus für kürzeste Pfade.
Da ist das Problem der kürzesten Pfade, Startknoten,
Zielknoten gegeben oder auch für alle Knoten oder sowas.
Und dann will ich halt einen kürzen Pfad von S zu V haben.
Und die Algorithmen, die wir hatten, waren eben Dextra,
Laufzeit-O von V-Q-Quadrat, Benmin Ford, V-L-E, Floyd Warshell, V hoch 3.
Und die Unterschiede waren Dextra, kommt nur mit Grafen,
klar, die keine negativen Gewichte haben,
Benmin Ford kommt auch mit welchen, klar,
die negative Gewichte haben.
Und Floyd Warshell,
bestimmt kürzte Pfade für alle Knotenpaare
Genau. Deixtra könnte man mal ausführen lassen,
also so als, ja vielleicht sogar als Ganzes,
wenn der Graf klein genug ist,
Benmon Ford und Floyd Warshell kann man nicht so gut ausführen lassen,
da seht ihr schon hier,
wenn ihr irgendwie euch die Laufzeiten anguckt,
dass sowas wie V mal E und V3 so,
das wird schnell irgendwie sehr groß und unübersichtlich und dann müsste man euch irgendwie den Grafen irgendwie zehnmal vorgeben und dann trägt man jedes Mal den Nachfolgezustand ein oder so,
aber das macht nicht so wirklich Spaß.
Was man da halt gut fragen kann, sind so Sachen irgendwie
Welche Algorithmen kennen Sie denn so für kürzeste Pfade und
was unterscheidet die oder so? Und dann sagt man,
naja, ich kenne den, den und den und irgendwie
da und da und damit kommen die klar.
Und das und das und das sind die Laufzeiten.
So, was kann man da gut fragen?
Oder eben den Dikestra vielleicht mal ausführen lassen oder zu fragen,
was ist denn der Unterschied zwischen der Extra und Bellman Ford?
Oder dass man nach diesem Relaxieren fragt, aber ich meine,
das wäre das Gleiche, wie irgendwie da extra ausführen zu lassen.
Ja, gut, das zu kürzesten Faden und zu Kurskal und Prim,
relativ flott,
weil wir das ja auch irgendwie auf den Übungszetteln
ganz gut hatten
Genau. Und da noch Flüsse, Flüsse wird jetzt ein bisschen dicker,
weil wir das noch nicht so viel wiederholt haben.
Aber auch da kann man im Grunde genommen primär so eine Aufgabe stellen,
wie irgendwie das Flussnetzwerk zu einem bestimmten Punkt zu geben und dann zu sagen,
okay, wie sieht jetzt der nächste Schritt aus?
Also das will man jetzt nicht irgendwie zehnmal iterativ machen lassen,
dann kann man viel zu viele Folgefehler machen,
sonst man es halt einmal machen lässt.
Ja, das Westnetzwerk dann auch, wenn es da zwei
Pfade gibt. Wenn wir dann den kürzesten oder der,
der den Fluss am meisten übergibt.
Das kann ja sein, dass man
nur ein Elektroteam hat
Sind, über denen der Unsinner wird. Können wir gleich nochmal machen,
wenn die beiden Algorithmen kommen, die wir hatten.
Erstmal Flussnetzwerk, gerichteter Graf. Zusätzlich hat jede Kante
irgendwie so ein Gewicht, so eine Kapazität, Entschuldigung,
hier ist irgendwie Kapazität 4, hier ist die Kapazität 10,
aber die hat halt schon irgendwie das Gewicht 7 oder 7 wird schon benutzt.
Und dann gibt es irgendwie die Quelle S und die Senke
Tee und alle Knoten liegen eh immer Faden von S zu T.
Das ist erstmal so ein Flussnetzwerk und gesucht ist dann eben
ein Fluss, der möglichst groß ist.
Der Fluss ist halt einfach dann eine Funktion,
die jeder kannte irgendwie eine Zahl zuweist
Und zwar so, dass irgendwie nicht mehr über eine Kante fließt,
als die Kapazität erlaubt, dass irgendwie Asymmetrie gegeben ist und Flusserhaltung hier,
dass im Grunde genommen nicht mehr aus dem Knoten rausfließt,
als auch reinfließt.
Genau, dann wird eben so ein maximaler Fluss gesucht,
dann guckt man sich jetzt den Startknoten an und den Fluss,
der da rausfließt oder eben auch den Zielknoten in den Fluss,
der da reinfließt und das ist eben der Wert des Flusses und den versuche ich eben zu maximieren.
Und dann war eben die Idee mit diesen Restkapazitäten,
mit dem Restnetzwerk und den Erweiterungsfaden zu arbeiten und hier sieht man jetzt,
dass Restnetzwerk zu diesem Grafen.
Und das Wichtige ist halt, dass irgendwie,
wenn ich hier sehe, von U zu V,
habe ich eine Kapazität 4 und im Moment einen Fluss von null.
Ah, Quatsch. Ein Fluss von minus sieben. Ich
habe hier eine Kapazität 4 von U zu V und weil ich
ja einen Fluss von sieben habe von V zu U,
jetzt Stichwort Asymmetrie hier, FUV ist das Gleiche wie minus FVU.
Das heißt, wenn ich einen Fluss von sieben habe von V zu U,
dann habe ich einen von minus sieben in die andere Richtung.
Wenn ich einen Fluss von minus sieben habe und eine Kapazität von vier,
naja, dann kann ich da noch elf rüber fließen lassen.
Also gibt es in diesem Restnetzwerk gleich eine Kante von U
zu V mit der Kapazität
Und von V zu U mit der Kapazität 3,
weil zehn ist die Kapazität, sieben fließt aber schon rüber,
das heißt, ich kann maximal drei rüber fließen lassen.
Also mal gucken, ob es stimmt. Von V zu U
sollte eine 3 stehen, von U zu V sollte eine Elf stehen.
Ja, sieht gut aus, ne? Drei von oben
nach unten, elf von da nach da.
Das ist halt das Restnetzwerk, was man bestimmt.
Da sieht man jetzt auch, da fließt noch gar nichts,
sondern das ist einfach nur wieder ein Flussnetzwerk mit Kapazität und so weiter.
Und dann kann ich da eben wieder einen Fluss bestimmen. Und die Idee ist halt,
man bestimmt jedes Mal wieder dieses Restnetzwerk,
dann bestimmt man da drin einen Fluss von S zu T und den,
also einmal ein Fahrt von S zu T und dann irgendwie,
was man da drüber fließen lassen kann und den addiert man dann auf den ursprünglichen drauf.
Und dann kann man wieder das Restnetzwerk bestimmen,
darin wieder ein Erweiterungsfahrt und immer so weiter,
bis das irgendwann nicht mehr geht
Dass das der Erweiterungsfahrt halt irgendeine Pfad von SCT,
dann guckt man, wie viel kann ich da drüber laufen lassen?
Hier kann ich jetzt maximal acht drüber laufen lassen.
Und die acht würde man dann eben drauf addieren auf den ursprünglichen, also auf.
Den hier. Dann hat man hier eine acht. Hier,
um hier acht drauf zu addieren, schiebt man erstmal die
sieben zurück von UZV und dann kommt noch einer dazu.
Also hier kommt dann null von zehn und da kommt eins
von vier. Hier kommt zwölf von zwölf und hier kommt
15 von 20. Dann hat man überall diesen Erweiterungsfahrt drauf addiert.
Genau, was bringt dich nicht weiter?
Oder galt es mir
Galt das mir? Du hast gesagt, bringt mich nicht weiter
. Ja, sein können. So, da ist die
Fort Falconson-Methode. Ich fange mit einem leeren Fluss an,
bestimme das Erweiterungsnetzwerk und dann darin Erweiterungsfahrt und dann erhöhe ich
F entlang dieses Fades und die maximal mögliche, um die maximal möglichen Fluss.
Und das wiederhole ich immer wieder, bis ich einen maximalen Fluss habe.
Und jetzt war eben die Frage, ob ich,
wie ich das mache, ob ich irgendeiner weit,
wenn ich mehrere Erweiterungsfahre haben darf, wer ich nicht nehmen darf und so weiter.
So wie es hier jetzt steht, bestimme eine Erweiterungsfahrt,
habe ich da halt irgendwie Wahlmöglichkeiten, welche ich bestimme.
Wenn ich dann irgendeinen habe, dann würde man hier nach
der Definition den Haltung das maximal mögliche bestimmen
Aber man hat unter Umständen ganz viele Pfade,
die man irgendwie nehmen kann, dann oben rum,
man unten rum, man direkt holt irgendwie sowas.
Deswegen heißt das auch Methode, weil das hier nicht genau
festgelegt ist. Gleich in dieser Geschichte von Edmonds Carp,
der sagt halt, bestimme dadurch Breitensuche einen kürzesten Pfad.
Da kannst du natürlich auch mehrere geben, irgendwie einen Omrum
mit drei Kanten, dann unten rum mit drei Kanten.
Dann könntest du wieder einen auswählen. Aber da ist halt
die Idee, einfach einen per Breitensuche in kürzesten.
Und dann wird der Algorithmus tatsächlich schneller. Haben wir nicht gemacht.
Warum, aber der wird dann halt tatsächlich schneller. Hier haben wir noch bewiesen,
dass das Ding tatsächlich korrekt ist,
dass wir diese Idee mit den Schnitten,
wo man halt gesagt hat,
Ich teile dieses Flussnetzwerk auf in eine Menge von Knoten S
und in eine andere Menge von Knoten Tee und in Gruß S
soll eben Kleiners dabei sein und ein großes Tee soll Klein Tee dabei sein.
Und dann kann ich eben gucken, welcher Fluss fließt durch
diesen Schnitt und was ist die Kapazität dieses Schnittes.
Und dann kann man halt mehrere Schnitte bestimmen und dann bei
den Schnitten gucken, welcher hat die minimale Kapazität.
Und dann stellt man eben dieses Max Floh mit Katheorien,
kann man dann zeigen, dass eben irgendwie der maximale Fluss den minimalen Schnitt entspricht.
Und damit kann man dann eben die Korrektheit dieser Fortfalconson-Methode zeigen.
Das nur, damit ihr das nochmal irgendwie seht und
in Erinnerung habt
Genau, da ist jetzt dieses Edmonds Carp,
der sagt eben, ermittel den Erweiterungsfahrt durch eine Breitensuche.
Ich nehme kürzesten Pfad von S nach Tee im Restnetzwerk und erhöht da
dann eben den Fluss bezüglich dieser CF von P. Genau,
und ich glaube, das war es zu Grafen.
Genau, das war das, was wir da zu den Grafen hatten.
Fragen. Zu den Grafen. Ich bin vorhanden auf gerichtet,
ich möchte keinen. Ob Spannbäume auf gerichteten Sinn machen,
man kann das machen, haben wir jetzt hier nicht gemacht.
Also da müsste man noch so allerlei drumherum,
glaube ich,
Sonst noch Fragen. Zum ersten, zum zweiten, zum dritten.
Okay. Ja, und dann Komplexitätstheorie, PNP und so weiter
. Was brauchen wir da so? Akzeptieren und entscheiden,
damit man irgendwie über P und so reden kann.
Also ich habe irgendwie eine Sprache oder eben nachher ein Problem.
Und die wird von einem Algorithmus entschieden, wenn eben jedes X,
was in Älteren ist, von A akzeptiert wird.
Also wenn ich bei den Jahrinstanzen Ja sagen kann und wenn
ich bei den Nein-Instanzen Nein
sagen kann
Und die Idee ist eben,
dass man quasi jedes von diesen Problemen, das wir bisher hatten,
auch in eine Sprache umdoktern kann, dass man sagen kann,
naja, wenn mir jemand ABC gibt und behauptet,
C ist gleich A plus B,
dann wird es halt eine Sprache.
Ich muss aber trotzdem im Grunde genommen das Gleiche machen,
weil ich muss irgendwie ausrechnen,
was die Summe von A plus B kommt da wirklich zäh raus.
Aber dann kann ich eben von akzeptieren, von Sprachen reden und
von dem Entscheiden von Sprachen und das hilft mir dann.
Genau, und beim Akzeptieren wird die zweite Eigenschaft hier nicht verlangt,
also da wird nicht verlangt,
dass ich immer anhalte
Und ich glaube, das war es auch schon zu erzählen,
was man so zu akzeptieren und entscheidend wissen muss.
Es geht eigentlich nur darum, dass man zeigen kann,
bei der Komplexitätsklasse P ist das das Gleiche und bald den ganzen anderen Komplexitätsklassen, die wir hatten, auch.
Aber dass es eben Sachen gibt, die man eben nicht entscheiden kann.
Genauso. Und wenn man jetzt so eine Zeitschranke einbaut,
wenn man jetzt sagt, der Algorithmus akzeptiert die Sprache im Polemialer Zeit,
wenn sie von akzeptiert wird und zusätzlich eben so ein K existiert,
sodass jedes X, was in der Sprache drin ist,
in Zeit, o von N hoch K akzeptiert wird,
wobei N eben die Länge ist.
Sprich, wenn ihr zehn, also wenn ihr einen Sortieralgorithmus habt,
der in O von Endquadrat abläuft, Denn bedeutet das,
um zehn Zahlen zu sortieren, braucht ihr irgendwie 100 Schritte,
um 100 Zahlen zu sortieren, braucht ihr 10.000 Schritte,
um tausend Zahlen zu sortieren,
braucht ihr dann eine Million Schritte,
also maximal im Worst Case und sowas.
Und vielleicht noch mit einer konstanten See davor, aber so als grobes Ding.
Das sagt das halt, wenn man sagt,
ich habe ein Ofen-Endquadrat-Algorithmus. Oder wenn ich sage,
Merch Thought geht in U von N mal Login,
dann weiß ich halt, naja, um jetzt tausend Zahlen zu sortieren,
brauche ich halt tausendmal Logorithmus von tausend.
Also Lograth muss von 1000, ist irgendwie 10, also nur noch 10.000 Schritte.
Wieder mit einer konstanten C davor, aber die ignoriere ich gerade mal.
Genau so. Und dann kann man halt sagen,
alle Sprachen, für die irgendwie ein Algorithmus existiert,
der die Sprachenpolymialzeit entscheidet,
all die Sprachen packe ich eben in die Komplexitätsklasse
Sprich, wenn man die ganzen Probleme,
die wir so hatten, wenn man sowas nimmt,
wie Kruskalsalgorithmus und sowas, wenn man das auf Sprachen ummünzt,
dann würde man sagen, all diese Probleme liegen in P,
weil es für all diese Probleme ein Polymialzeitalgorithmus gibt.
Bisher hatten wir all die Probleme,
die wir jetzt gerade hatten, waren alle MP zu lösen.
Also wenn ihr euch an die Laufzeitschranken erinnert,
da war nichts Exponentielles dabei, das waren alles Polynome.
Anne Malock-in, also Anne Malock-in, das ist kein so schönes Polynome,
aber ist halt nach oben beschränkt durch Endquadrat, also ist das auch okay.
So, und NP, EnP konnte man jetzt entweder über Nicht-Eterminismus
machen oder bei Verifikationsalgorithmen, machen wir das mal mit Verifikationsalgorithmen.
Das ist ein Algorithmus, der kriegt zwei Eingaben,
X und Y, X ist die eigentliche Eingabe.
Y ist das Zertifikat, das mich davon überzeugen soll, dass X eine Jahrinstanz ist.
Und die von A verifizierte Sprache, das sind gerade die Xe,
für die es eben irgendein Y gibt mit der Eigenschaft,
dass dieses Zertifikat mich überzeugt, dass es eine Jahrinstanz ist.
Also als Beispiel gegeben großer Graf, zehn Knoten,
von denen behauptet wird, dass es eine Clique sind,
sind dann Zertifikat und dann gucke ich halt,
sind diese zehn Knoten wirklich in dem Grafen drin und sind
die alle paarweise miteinander verbunden und wenn ja,
überzeugt mich das,
dass das
ein Jahrinstanz ist
Oder gegeben Graf. Und ich interessiere mich jetzt,
gibt es einen möglichst langen Fahrt von S zu Tee.
So, jetzt frage ich mich nach möglichst lang,
weil das ist das Optimierungsproblem, sondern ich frage,
gibt es irgendwie in die Fahrt, der mindestens die Länge 1000 hat?
Dann kommt einer daher und sagt, ja, den gibt es.
Das überzeugt mich jetzt noch nicht so,
aber er sagt mir, naja,
wenn du die und die und die Kanten entlang gehst,
dann hat der Fahrt die und die Länge.
Und dann habe ich die Kanten, dann gucke ich einmal,
kann ich die Kanten wirklich entlang gehen,
führt mich das von S zu T und sind die Kosten mehr als 1000.
Dann hat mich das Zertifikat auch überzeugt. Genau so.
Und dann kann man all diese Probleme eben,
oder all diese Sprachen, für die es sind Verifikationsalgorithmus gibt,
all die kann man wieder aufsammeln und die bilden dann eben
die Komplexitätsklasse NP
Wobei man das dann noch so machen muss,
dass man die Länge des Zertifikates hier beschränken muss.
Also hier ist es ja noch nicht gefordert,
dass das Zertifikat irgendwie eingeschränkt sein muss.
Und wenn man bei der Komplexitätsklasse NP ankommen will,
dann muss man sagen, das sind die Sprachen,
bei denen mich von der Richtigkeit eines Xes ein Zertifikat überzeugt,
das nur polinumielle Länge in X hat.
Also wo ich dann auch wieder sage,
es gibt so ein Polynom, Endquadrat oder so.
Und dann muss es, wenn die Eingabeninstanz 100 ist,
dann muss mich eben irgendwie das Zertifikat,
darf dann höchste Länge 10.000 haben,
um mich von der Richtigkeit
zu überzeugen
Genau, das ist NP. Und dann kann man sich angucken,
P akzeptieren und ein entscheidendes identisch, warum,
wenn ich es akzeptieren, also wenn ich es entscheiden kann,
kann ich es auch akzeptieren, aber wenn ich es akzeptieren nur kann,
ist die Frage, kann ich es auch entscheiden,
also kann ich auch bei Nein-Instanzen anhalten?
Naja, dann kann ich mir überlegen, ich weiß ja,
es gibt eine Laufzeitschranke, also kann ich die ausrechnen?
Und dann kann ich nach so und so vielen Schritten einfach aufhören.
Wenn ich bis dahin noch nicht Nein gesagt habe,
danach kommt auch kein Jahr mehr. Und dann kann ich
die entscheiden. Und für Probleme in NP kann man zeigen,
deterministisch kann ich die eben mit so einer exponentiellen Laufzeitschranke lösen.
Ich gehe alle Zertifikate durch,
die möglich sind und rechne für jeden dann
den Verifikationsalgorithmus aus
Das kann man machen. Es ist halt wichtig zu wissen,
dass man weiß, P, alle Probleme,
die da drin sind, kann ich entscheiden.
Und NP, alle Probleme, die da drin sind, kann ich auch entscheiden.
Und zwar deterministisch. Nur eben mit exponentieller Laufzeitschranke. Das ist einerseits schön,
weil ich weiß, ich kann sie entscheiden, andererseits blöd,
weil ich weiß es nicht, praktikabel dauert viel zu lange.
Und dann hat man hier noch irgendwie die Abschlusseigenschaften für die Komplexitätsklassen.
Was man da eben so als Fragen raus extrahieren kann,
ist sowas wie irgendwie, wir geben L1L2 aus P,
beweisen sie doch,
dass die Vereinigung auch wieder ein P ist oder der Schnitt oder irgendwie sowas.
Das sind auch so Sachen, die relativ einfach sind.
Da würde man dann sagen,
wenn L1 und L2 in P sind,
dann gibt es Polemialzeitalgorithmen,
die das entscheiden
Und wenn ich jetzt irgendwie so ein X vorgelegt kriege und ich soll entscheiden,
ob das in eins vereinigt L2 drin ist,
dann führe ich erst den Algorithmus für L1 aus,
dann den Algorithmus für L2,
wenn einer davon Ja sagt, bin ich zufrieden.
Genauso wie man irgendwie zwei Methoden hintereinander in Java aufrufen kann oder so,
wenn die beide eine Laufzeit haben von Endquadrat,
dann weiß ich, wenn ich die hintereinander ausführe,
dann ist die Laufzeit dann zweimal in Quadrat oder so im Worst Case.
Und so, deswegen wird das hier auch von Polynom irgendwie nicht schlimmer.
Ja, und was halt auffällt, ist,
hier tritt irgendwie bei Petritt noch das Kompliment auf, L1,
Overline und hier tritt das eben nicht mehr auf bei NP.
Also das hier ist die Sprache quasi, sie Ja- und Nein-Istanzen
gerade umgedreht. Das kann ich bei P halt machen,
weil ich irgendwie noch so und so viele Schritten fertig
bin und dann einfach Ja und Nein austauschen kann.
Und hier kann ich das nicht machen,
weil ich theoretisch dann für Nein-Instanzen wissen müsste,
dass es kein Zertifikat gibt, was mich von der 9-Instanz überzeugt.
Und das ist halt schwieriger zu realisieren. Genau,
und dann kann man sich diese Klasse QNP definieren,
dass man sagt, wenn L Quer & NP ist,
dann ist Alien QNP und da gibt es halt diese vier Möglichkeiten,
wie das Universum so aussehen könnte.
Und man weiß halt nicht so genau, welche zutrifft.
Und die letzte ist die wahrscheinlichste
Zu merken, gibt es da nicht so viel,
wenn du dir die alle vier Male aufmalst,
dann wirst du sehen,
dass du dir das auch so einfacher erarbeiten kannst.
Also dass P wahrscheinlich eine Timingmenge von NP ist,
das nimmt man so als Wissen hoffentlich mit aus der Vorlesung.
Und dann weiß man ziemlich schnell, wie das aussehen muss.
Also so muss, du kannst sie dir mit Vendiagrammen
recht schnell überlegen, wie das aussehen muss.
Deswegen da unten auch mal die Male auf, dann siehst du,
dass das gar nicht so viele Möglichkeiten sind da.
Also zum Beispiel lässt sich die erste ja ziemlich schnell,
als wenn Diagramm zeichnet, das ist ein Kreis,
wo alles drin ist.
Das zweite ist genauso einfach,
das ist P und dann ist da halt NP
gleich Co-NP drum
Und dann faltet sich das halt immer weiter so auf.
So, letzter Reduktion, wir sind noch gleich fertig.
Reduktion, wenn ich jetzt, wofür haben wir das gebraucht?
Ich wollte zeigen, dass für es für Probleme wahrscheinlich keinen schönen,
schnellen Algorithmus gibt. Sprich, ich will zeigen,
das Problem liegt wahrscheinlich tatsächlich nur in NP und nicht in P.
Und dann war die Idee, dass man schwierige Probleme,
also Probleme, von denen man schon weiß,
dass sie schwierig sind, auf neue Probleme reduziert.
Und dann kann man sagen, naja,
dann ist das neue Problem wahrscheinlich auch nicht schnell lösbar.
Und dann war die Idee, so eine Reduktion anzugeben,
das heißt, eine Funktion F,
die ich im Pulli mehr der Zeit berechnen kann,
mit der Eigenschaft XSNL1 genau dann,
wenn F von X in A2 ist
Schreibweise eh so. L1, kleiner gleich, L2. Sprich,
die Idee ist, wenn X eine Jahrenstanz ist,
dann ist FONX auch eine Jahrenstanz, wenn X eine 9-Instanz ist,
dann ist FONX auch eine 9-Instanz.
Und damit kann man sich dann irgendwie Vollständigkeit einführen und eine
Sprache ist NP vollständig, wenn sie eben in NP ist.
Und wenn sich jedes andere Problem aus NP darauf reduzieren lässt.
Und den Schritt macht man meistens so,
dass man dann eben schon eine Sprache nimmt, von der man schon weiß,
dass die NP vollständig ist und darauf auf das neue L reduziert.
Das, ja, warte, hier, glaube ich.
Wenn ich zeigen will, dass eine Sprache NP vollständig ist,
dann zeige ich, dass sie ein NP ist,
dann wähle ich mir eine NP vollständige Sprache aus.
Und dann gebe ich eben eine Reduktion von L-Strich auf L
Sprich, gebe es einen Algorithmus an,
der irgendwie so ein F berechnet mit eben der Eigenschaft X-NL-Strich,
genau dann, wenn er von X-NL ist.
Und die muss eben noch in Polymialzeit sein. Und mit
den ganzen Sätzen hier folgt dann quasi die Richtigkeit dieses Satzes.
Also hier diese Transitivität bei dem zweiten Satz,
deswegen reicht mir das eben ein NP-vollständiges Problem zu nehmen.
Dann weiß ich auch, ich kann alle aus NP auf
dieses MP-Vorständige reduzieren und das Neue vollständig auf das Neue,
also kann ich alles auf das Neue reduzieren.
Dann der erste hier, der hilft mir zu sagen nachher, oh,
dann ist wahrscheinlich mein neues Problem L2 nicht in P,
weil wenn das in P wäre,
dann wäre das NP-vollständiger auch in P und dann wären
alle anderen
auch in
Und dann wäre plötzlich P gleich NP und das glaubt man
nicht so richtig. Also kann man Schlussfolgern,
wenn ich gezeigt habe, dass das eine NP vollständig ist,
dass es wahrscheinlich eben nicht ein P ist.
Da steht es dann auch nochmal als Satz,
wenn LNP vollständig ist, dann würde daraus,
findest du jetzt NP ist, folgendes NP gleich P ist.
Genau. So, das sind vier exemplarische NPV-ständige Probleme,
die wir hatten. Satt CNF, 3CNF und Clique,
am prominentesten, glaube ich, die letzten beiden,
so mit denen kann man immer versuchen,
ein bisschen zu arbeiten.
Genau, die eben benutzen,
um für neue Probleme nachzuweisen,
dass die NPV vollständig sind
So, das war die Vorlesung. Kurzer Ausblick noch,
wenn man jetzt weiß, dass ein Problem irgendwie schwierig ist,
das ist ja erst mal doof.
Dann weiß ich erst mal, es lässt sich wahrscheinlich nicht
effizient lösen. Was macht man jetzt so als Mensch?
Man will das ja, wenn das in der Anwendung auftritt,
will man es halt trotzdem schnell lösen.
Und dann kann man halt irgendwie versuchen, mit verschiedenen Ansätzen daran zu gehen.
Man kann irgendwie die betrachteten Strukturen einschränken, sprich,
vielleicht wollt ihr gar nicht Klicker auf dem Allgemeinen Grafen bestimmen,
sondern ihr wollt Klicker nur auf dem Baum bestimmen.
Auf dem Baum ist das total einfach. Oder ihr sagt,
naja, ich weiß irgendwas über meinen Grafen,
ich weiß, da treten überhaupt keine Kreise auf.
Na gut, dann ist ein Baum.
Oder ihr wisst, da treten nur Kreise der bestimmten
Länge auf
Irgendwie solche Sachen, dann könnt ihr irgendwie die betrachtenden Strukturen einschränken.
Oder ihr könnt versuchen, ab Proximationsverfahren zu benutzen, dass ihr sagt,
naja, ich muss ja gar keine maximale Klicke bestimmen,
mir reicht es irgendwie, wenn die möglichst gut ist.
Ich muss nicht den günstigsten Preis für die Hotelbuchung machen,
mir reicht es, wenn es 95 Prozent ist oder so vom günstigsten.
Alles gut. 95, 105 vom günstigsten, ne? Also ein bisschen mehr randomisierte Verfahren,
dass man Algorithmen benutzt,
die irgendwie so mit Cointoss arbeiten oder irgendwie Münzwürfen,
Verfahren, bei denen man dann vielleicht gar nicht weiß,
dass sie immer das Richtige, oder dass sie immer ein Ergebnis liefern,
wenn ich zum Beispiel weiß,
naja,
nur mit 60-prozentiger Wahrscheinlichkeit liefert mir dieser Algorithmus ein Ergebnis
und mit 40 Prozent sagt er halt,
weiß ich nicht
Und dann kann ich sagen, na gut,
dann führe ich das Verfahren ganz, ganz oft auf.
Wenn das viel schneller ist, als mal deterministisch ist,
dann ist das cool,
weil dann kann ich das zehnmal ausführen und drücke damit irgendwie die Wahrscheinlichkeit,
dass er sagt, weiß ich nicht,
doll nach unten oder ich führe es 100 neu aus oder tausendmal oder so.
Paradebeispiel dafür, so Primzahlentests und sowas bei kryptographischen Verfahren,
da benutzt man randomisierte Algorithmen. Da weiß man zwar mittlerweile,
dass es einen deterministischen gibt,
aber obwohl der schon viel schicker ist als die ursprüngliche Vorschlag,
ist halt immer noch langsamer als die sehr,
sehr schnellen randomisierten.
Führe ich halt iranomisiert ein paar Mal aus und
dann bin ich mir ziemlich sicher
Führt manchmal immer noch so zu Bauchschmerzen,
dass man irgendwie sagt, randomisiert ist,
dann weiß ich ja gar nicht, stimmt das und so.
Man drückt im Grunde genommen die Wahrscheinlichkeit so weit runter,
dass es wahrscheinlicher ist, dass man Hardware-Fehler drin hat,
als dass das Ergebnis von dem Algorithmus nicht mehr stimmt.
Weil Hardware-Fehlern, da denkt ja auch keiner großartig drüber nach,
dass das Ergebnis vielleicht nicht stimmen könnte,
weil es gerade ein Bitflip irgendwie noch im Rechner gab oder so.
Heuristiken, noch ein anderes Thema und fix Parameter-Algorithmen, noch ein anderes Thema.
All die Sachen kann man halt Also mit all den Sachen
kann man versuchen, an diese NPHten Probleme ranzugehen.
Man kann daraus natürlich auch irgendwie für die Probleme,
die wir hatten, möglicherweise effizientere Algorithmen rausziehen.
Also was wir eben hatten, randomisierte Algorithmen für den Primzahlentest,
da weiß ich, das ist gar nicht mehr NPHd,
aber der randomisiert das halt schneller.
Also das können auch so Verfahren sein, die man auf
andere Probleme losschießt, einfach nur um sich schneller zu lösen.
Genau, und was halt passiert, ist,
dass man quasi diese Grenze des Praktischmöglichen immer weiter versucht herauszuschieben,
dass man einerseits mit Algorithmen versucht,
Sachen möglichst effizient zu lösen
Quasi Schranken von oben, immer weiter nach unten zu drücken,
mit der Komplexitätstheorie, also sowas wie NP-Vollständigkeit und so,
die Grenze von unten nach oben zu machen,
bis das irgendwann matcht und man weiß, okay,
besser als so geht es nicht oder so.
Und dann merkt man besser,
so geht es nicht und dann versucht man irgendwie trotzdem drumherum
zu kommen und dann versucht man es zu approximieren zum Beispiel und dann kommt wieder Komplexitätstheorie und sagt,
besser als so, lässt es sich aber nicht approximieren.
Also wenn ihr dann Approximationsergebnis habt,
der irgendwie um zwei Prozent um das Optimum herum flackert,
dann sagt vielleicht irgendwann jemand aus Komplexitätstheorie, ja,
und besser geht es auch gar nicht.
Dann wisst ihr, ihr braucht nicht noch einen besseren Approximationsergebnis
zu suchen. Und die beiden Themengebiete,
die bedingen sich quasi so, dass man versucht,
diese Grenze immer weiter hinauszuschieben und trotzdem immer wieder nach
neuen Grenzen
zu suchen
Und wenn euch das interessiert, gibt es nächstes Sommersemester von Andrea.
Eine Vorlesung, Lösungsstrategien für Fur-Lösungsstrategien für NP-Schweere Probleme der kombinatorischen Optimierung.
Also das der kombinatorischen Optimierung, da kann man mal so ignorieren.
Wichtig ist, Lösungsstrategien für NP schwierige Probleme. Wenn mich das interessiert,
hier 2 plus 2. Im Wahlbereich kann man das machen
und Teilnahme ist möglich, hat er gesagt,
wenn man entweder A und D oder Optimierung für Informatik erfolgreich abgeschlossen hat.
Genau, und das war die Werbung für ihn.
Und noch ein letzter Hinweis,
wenn euch das Thema so interessiert mit Algorithmen,
dann könnt ihr nochmal die Folie so ein bisschen Revue passieren
lassen und ein Buch nehmen und dabei darauf achten,
was für Techniken benutzt wurden
Das ist, haben wir in der Vorlegung hier und da
immer mal wieder gesagt, aber nicht so richtig in den Schwerpunkt draufgelegt.
Das kann man mal machen, vor allem,
wenn man sich doller, noch viel doller auf Algorithmenentwurf schulen will,
dass man halt mit solchen Algorithmentechniken, Ready-Verfahren,
die weit in Konka und so weiter,
dass man die Verfahren mir im Vordergrund hat.
Greedy hatten wir, die weit in Konka,
hatten wir Backtracking, hatten wir im Grunde genommen auch dynamisches Programmieren,
ist die weit in Konka mit noch zusätzlichen Berechnungen,
Branch and Bound ist Backtracking mit noch zusätzlichen Berechnungen.
Genau, das könnt ihr euch bei Zeit und Interesse nochmal angucken,
passt auch gut zu der eben genannten Vorlesung oder zu
der Algorithmik-Vorlesung im Masterstudium
So, Fragen. Zum ersten, zum zweiten, zum Fragen.
Sehr schön. Dann wünsche ich noch viel Spaß bei der Klausurvorbereitung, Konsole.
Genau, wir sehen uns dann gleich ein Jahr.
Ob es Musterlösung zur Probeklausur geben wird? Nein. Ihr
müsst ja lernen, selbst zu bewerten, ob eure Lösungen richtig sind.
Nein, also wir machen das mit der, dieses Probeklausur-Dingsbums.
Ich stelle das gleich rein und dann könnt ihr das rumrechnen und machen
tun und dann können wir nächste Woche im Repertorium ordentlich darüber reden,
wenn ihr Fragen an irgendwelchen Stellen habt.
Ansonsten tatsächlich jetzt ohne Flachs. Es ist gut,
wenn ihr lernt, eure Lösung zu bewerten,
weil wenn du jetzt irgendwas suchst, wo du sagst,
ja, wäre ja cool, wenn ich dazu eine Lösung hätte oder so,
dann kannst du dir irgendwie ein beliebiges Algorithmenbuch suchen und da irgendwie das,
was da in der Beispielsektion gerade ist, durchlesen.
Also es bringt jetzt nicht so,
man ist da so fokussiert drauf, dass man irgendwie denkt,
oh, da würde ich jetzt gerne noch die Lösung und da würde ich jetzt gerne noch die Lösung und so.
Aber irgendwann bringt es nichts mehr. Dann hast du halt 500 Sachen mit O-Notationen,
wo du eine Lösung zu hast und dann sagst du,
oh, jetzt hast du mir nochmal fünf neue gestellt,
kriege ich dafür auch eine Lösung, das bringt irgendwann nichts mehr so.
Es ist besser, wenn ihr tatsächlich lernt, euren eigenen Ergebnissen zu vertrauen.
Und wenn ihr halt euch unsicher seid, dann könnt ihr jederzeit fragen.
Schreibt ihr also entweder nächste Woche oder ihr schreibt mir eine E-Mail oder so,
Genau, sonst noch Frage.
Gut, dann fröhliches Lernen und wir kommen zum Ende für heute.
Toi, toi, toi und so, die Veranstaltung ist quasi offiziell beendet.
Nächste Woche machen wir noch Repetitorium und wir machen zehn Minuten
Pause und dann machen wir gleich noch ein bisschen,
also wer will, kann gleich schon Fragen stellen.
Ansonsten sehen wir uns nächste Woche und wir sind am Ende.