So. Mein letztes Mal vor Weihnachten. Mit Beflaggung heute, genau, ne?
Muss. 14 Stunden und 37 Minuten noch, so grob geschätzt.
Wer hat Karten? Wer weiß nicht, wovon ich rede.
Keiner, großartig. Zwei haben nur Karten, echt?
Mann. Na gut. Heute, nochmal zu den Graf-Algorithmen
für Spannbäume, einmal ganz kurz in der Wiederholung.
Und dann die Überleitung zu den kürzesten Faden
Und dann wollte ich, wenn das noch Zeit bleibt,
nochmal so ein bisschen kurz Revue passieren lassen,
was wir jetzt so die letzten Monate gemacht haben.
Ein Bild malen und dann machen wir Feierabend und nächstes Mal
fangen wir dann an im neuen Jahr mit den Flüssen und
machen noch einmal so einen Blick auf Techniken, Zusammenfassung,
Repetitorium, Feierabend, wenn es schon Ende Januar,
dann können wir Prüfung schreiben.
Minimale Spannbäume, Kruskal und Prim. Habt ihr Fragen dazu?
Kruskal war die Idee, ich nehme immer eine Kante,
die möglichst günstig ist. Prim sehen wir gleich nochmal,
der ist quasi immer von dem Teilbaum,
den er schon konstruiert hat,
ausgegangen und ist dann weitergegangen dahin,
wo es
möglichst günstig ist
Um schon mal das mit den Techniken vorzubereiten. Krustkalte Song,
sogenannte Greedy-Algorithmus, also so ein gieriger Algorithmus,
weil der sich quasi die Elemente nur einmal anguckt.
Also der macht zwar vorher so ein bisschen Pre-Processing,
indem er irgendwie die Kanten sortiert und sowas, aber danach,
wenn ihr euch an das Verfahren noch mal erinnert,
guckt er sich jede Kante tatsächlich nur einmal an.
Der guckt sich eine Kante an, die möglichst günstig ist.
Und dafür sortiert er die vorher, dann nimmt er die.
Und wenn da durch einen Kreis entsteht, dann sagt er,
naja, die will ich nicht, schmeißt die weg.
Und wenn kein Kreis entsteht, sagt er, oh,
die finde ich gut und nimmt die. Und die Entscheidung,
die er da trifft, hinterfragt er später nie wieder.
Also er macht ja nie sowas wie,
wenn ich eine neue Kante hinzufüge, gucke ich mir noch mal an,
welche habe ich bisher genommen, vielleicht nehme ich eine davon weg,
um die neue zu nehmen oder irgendwie sowas,
das macht er nicht.
Sondern er guckt sich jede Kante genau einmal an
und nimmt sie oder nicht
Das ist so ein ganz klassisches Charakteristikum von Ready-Algorithmen. Die andere Technik,
die wir hatten, war die White and Conquer, diese Idee, irgendwie alles immer wieder zu halbieren. Backtracking kennen wir auch schon irgendwie,
dass man irgendwie in die Tiefe geht und dann irgendwie möglicherweise eine Entscheidung irgendwie hinterfragt,
hinterruft und dann irgendwie wieder zurückgeht,
also so wie man satt zum Beispiel irgendwie lösen könnte,
dass man irgendwie eine Belegung rät, dann klappt das vielleicht nicht,
dann sagt man, ja gut,
dann setzt sich die letzte Gesetzesvariable doch nicht auf eins,
sondern auf null und so und dann hat man irgendwie so ein Backtracking-Verfahren.
Und Branch in Bound wollte ich mich mir mit euch
nochmal angucken und dynamisches programmieren. Ja, genau,
also das zu Kursgal und Prim kann man hier nochmal sehen, Prim macht
Bei Prim war die Idee, er fängt auch irgendwo mit
einem Startknoten an, hier dieses oben links in der Ecke.
Und dann guckt er sich quasi die Nachbarn an und setzt bei denen
diesen Zahlenwert in der Mitte auf den Wert der Kante irgendwie.
Und jetzt sagt er hier, acht, wenn man irgendwie
über Ader hingeht und hier elf, wenn man über Ader hingeht.
Und von denen bis dato entdeckten Knoten nimmt er dann den
mit den kleinsten Gewicht. Das Gewicht da sagt quasi aus,
wenn man mich zum Spannbaum hinzufügen will, kostet das so und so viel.
Also er sagt, das kostet dann acht und er sagt,
das kostet elf, dann ist acht irgendwie günstiger,
also nehme ich den hier.
Und dann guckt man wieder, was entdecke ich von da
aus. Und im nächsten Schritt würde man hier die Knoten
C&D entdecken
Den kann man mit zwei entdecken, den kann man mit drei entdecken.
Und wenn man irgendwann nachher bei dem Knoten D ist,
dann stellt man fest, wenn ich von D aus E hinzufügen will,
dann kostet mich das nur sechs und das ist günstiger als elf.
Also baue ich das um. Dann sage ich nicht mehr,
dass ich eh über die Kante hier zwischen A und E hinzufügen will, sondern über D und E.
Und dadurch, dass ich halt immer denen hinzunehme,
gerade wo das am günstigsten ist, kriege ich nachher so einen minimalen Spannbaum.
Genau, das macht prim. Und die primäre Idee bei DIXtra ist jetzt dieses,
Den einen Test, da passiert ja eigentlich nur ein Test,
wo gefragt wird, also wenn hier jetzt schon mich den entdeckt hätte,
dann würde hier gefragt werden,
ist dieser Wert größer als die Kante hier?
Und falls ja, setze ich halt irgendwie um.
Und Deixtra setzt das, indem er sagt,
ist der Wert, der da bis jetzt steht,
günstiger als der Wert, den ich hätte,
wenn ich den von denen nehme und sechs dazu addiere.
Dadurch ist es halt der Wert vom kürzesten Weg.
Im Moment stehen da als Werte quasi die Kantengewichte,
die ich bezahlen muss, wenn ich die Knoten zum Baum hinzufügen will.
Und wenn ich das so mache wie Deixtra,
dann wird er halt addiert und dann kriege ich kürzeste Pfade raus.
Beispiel, das ist das,
was bei Prim passieren würde da jetzt
mit der 2 und der
Und wenn man das bei der Extra macht,
dann kommt da eben nicht zwei und drei hin,
sondern die acht, weil die habe ich ja schon bezahlt,
um zu B zu kommen, plus zwei,
dann merke ich mir eben, dass ich zehn zahlen muss,
um zu C zu kommen und elf zahlen muss,
um zu D zu kommen.
Und dann wird es eben nachher nicht mehr günstiger,
wenn ich den jetzt hier gleich entdecke dann und hier elf zahlen soll,
dann wird es eben nicht mehr günstiger über die Sechserkante dahin zu gehen,
weil da würde ich irgendwie 17 zahlen,
sondern es ist eben günstiger über die Elferkante,
ganz oben zu gehen.
Einmal vom Staat durch, wir fangen da an,
setzen die beiden Knoten ganz normal auf acht und elf,
dann ist der günstigste der B-Knoten
Und jetzt kommt eben dieser Schritt, wo ich sage,
okay, dann addiere ich.
Jetzt gucke ich mir wieder an, welcher ist der günstigste.
Das ist jetzt der hier. Da passiert aber nichts,
weil wenn ich von dem C-Knoten zu D gehen will,
dann müsste ich 10 plus 4 zahlen, also 14.
Das bringt nichts. Und jetzt könnte ich mir halt einen von
den beiden aussuchen hier, weil die beide gleichgünstig sind.
Ich habe jetzt mal mit dem angefangen und dann würde man
jetzt den F-Knoten hier entdecken und sagen, oh,
der kostet 11 plus 12, also 23.
Jetzt denkt man als nächstes den D-Knoten,
weil der günstiger ist, eine 11 ist günstiger als 23.
Und jetzt würde man hier auch sagen, 11 plus 7 wäre 18,
18 ist günstiger als 23. Also es ist schöner,
wenn ich Wenn ich einen kürzesten Weg von A nach F suche,
eben nicht, was ich im Moment mir hier denke,
über E gehe, sondern wenn ich über D-E gehe.
Deswegen wird das umgesetzt und dann wird wieder
der günstigste Knoten aus der Q oder so genommen.
Das ist jetzt das F und dann macht man halt so weiter.
Das ist so der Hauptunterschied, dass eben an dieser Stelle jetzt,
an der nicht mehr geguckt wird, ist sieben kleiner als 23,
sondern ab elf plus sieben kleiner als 23 ist.
Ja, genau, und dann wandert das so weiter.
Jetzt guckt mal wieder, was entdecke ich Neues,
entdecke ich die beiden neu, was ist davon am günstigsten?
Da gehe ich dann hin, dann mache ich irgendwie
so weiter
Genau. Das ist die Idee bei der Extras-Algorithmus. Sehen wir
gleich nochmal im Detail, wie man den implementieren kann,
aber so von der Idee her sehr ähnlich zu primen.
Genau, und da ist das Problem der kürzesten Pfade.
Ich kriege so einen gerichteten Grafen mit einer Gewichtsfunktion und einem Startknoten S
und jetzt suche ich eben für jeden Knoten einen Pfad,
der in S beginnt und in V endet.
Und der dann eben möglichst günstig ist, günstig ist.
Ich addiere die ganzen Kantengewichte auf und das,
was dann rauskommt, ist eben quasi das Gewicht des Weges
und das
will ich minimieren
Genau, und jetzt gibt es da so unterschiedliche Varianten,
so wie es da geschrieben ist, hat man einen Startknoten und guckt von dem für alle Zielknoten, was der günstigste Weg ist.
Bei dem Beispiel hier war das auch so, wenn ich jetzt,
A ist mein Startknoten und wenn ich jetzt von irgendeinem Knoten kürzesten Weg wissen will,
von A zu diesem Knoten, dann fange ich halt bei dem Knoten an,
von mir aus bei H hier und dann gehe ich quasi immer diese,
was wir immer in dem P von V gespeichert haben,
die Dinger, die gehe ich dann immer rückwärts,
also weiß ich, der Vorgänger von HSF,
der Vorgänger von FSB, der Vorgänger von DSB,
der Vorgänger von BSA,
und dann habe ich einen kürzesten Weg von Startknoten zum Zielknoten.
Und das kann ich halt bei jedem Knoten machen,
deswegen ist das so ein Single Source kürzeste Pfade,
dass ich quasi eine Quelle habe,
aber beliebige Ziele
Und das kann auch anders machen, das wären jetzt so die Varianten,
die zweite ist wahrscheinlich so die,
die man am ehesten kennt, dass man sagt irgendwie,
ich habe einen Start und einen Zielknoten und will da für einen kürzesten Pfad wissen,
äh Quatsch, der dritte, Entschuldigung, der dritte.
Der zweite ist ein bisschen ungewöhnlich, dass man sagt,
ich habe einen Zielknoten und alle anderen Knoten sollen Startknoten sein
und mich interessiert, wie ich von da da hinkomme.
Kann man vielleicht auch mal brauchen,
wenn der Zielknoten irgendwie sowas ist,
wenn ich irgendwie ein System modelliert habe und der Zielknoten ist ein Homestate und ich will,
dass ich von jedem Zustand im System da hinkommen kann oder so,
dass man möglichst schnell gehen oder irgendwie sowas
Genau, das vierte für jedes Knotenpaar an kürzesten Pfadfinden,
dass egal wo ich bin, ich weiß,
wie ich am günstigsten da hinkomme, das sind so die Varianten.
Genau, jetzt kann man sich angucken,
ob man wirklich für jede dieser Varianten einen eigenen Algorithmus entwickeln muss oder
ob man das irgendwie auf eine von den Varianten zurückführen kann.
Und beispielsweise erste und zweite, wie kann man das machen?
Kann man eins auf das andere zurückführen
Dann ja, und wenn wir im Gerichteten sind?
Genau, und drehe ich alle Kanten nur mit mir fertig,
ne? Genau, am Ungerichteten hat er eben gesagt,
ich nehme dann einfach meinen Zielknoten als Startknoten und gehe dann von dem aus,
dann kriege ich das alles in Ungerichteten.
Und wenn es ein Gerichteter ist,
dann drehe ich eben alle Kanten um und mache dann genau das,
ne, starte dann beim Zielknoten von zwei und nenne den einfach den Startknoten von eins,
aber im Grafen, bei dem alle Kanten umgedreht sind.
Sprich, wenn ich Variante zwei haben will,
dann reicht mir auch ein Algorithmus für Variante eins, ne?
Das ist okay
Dann der hier, da ist es so, da könnte man jetzt sagen,
naja, das wäre schon spannend, das zu machen.
Die Variante 3, da ist es aber so,
dass kein Verfahren bekannt ist, dass drittens löst und tatsächlich
echt schneller ist als ein Verfahren für eins.
Das heißt, ich kann auch einfach das Verfahren eins
machen und dann weiß ich meine Lösung für drei auch.
Also es bringt keinen großartigen Geschwindigkeitsgewinn, wenn ich drei löse.
Zumindest jetzt hier so asymptotisch. Und das vierte hier,
das könnte man auch so machen,
dass man einfach Variante eins für jeden Staat,
also für jeden Knoten als Startknoten durchgeht
Dann weiß ich das auch. Da ist es aber so,
da gibt es dann tatsächlich schnellere Algorithmen und einen,
den wir ganz kurz antouchen wollen, ist dieser Floyd-Waschel-Algorithmus.
Kennt ihr vielleicht schon aus DM oder so? Der löst das Problem auch,
den touchen wir aber nur einmal ganz kurz an.
Ja, das sind so die vier Varianten. Deswegen reicht es
im Grunde genommen, sich auf Variante 1 zu beschränken.
Und jetzt kann man sich noch so ein bisschen Gedanken machen,
will ich negative Gewichte haben? Also dieses Verfahren,
was wir eben so am Beispiel illustriert haben,
das klappt halt nicht mit negativen Gewichten,
weil ich da dann eben nicht so was sagen kann,
wie wenn ich schon zu einem Knoten gekommen bin,
dann gibt es auf keinen Fall einen günstigeren Fahrt,
weil ich ja vielleicht für irgendeinen späteren Knoten plötzlich eine ganz tolle Negativkante zurück habe oder so.
Und dann müsst ihr das hinterfragen. Das heißt,
so wie eben beschrieben, klappt es nicht mit negativen Gewichten
Gerichtet ungerichtet, ist immer egal quasi,
weil wenn die ganzen Verfahren, die wir vorstellen,
alle mit gerichteten Grafen funktionieren, dann funktionieren sie auch mit Ungerichteten.
Warum? Genau, ne? Ich nehme eine ungerichtete Kante,
mache daraus zwei gerichtete, fertig. Ja. Kurze Eigenschaft,
kürzester Pfade, bevor wir dann diesen Algorithmus von da extra machen.
Intuitiv, meistens klar, wenn ich so einen gewichteten,
gerichteten Grafen habe und ich habe einen kürzesten Pfad von V1
bis VK
Dann kann ich mir quasi eine Teilfahrt rausnehmen von einem
der VIs zu einem der VJs und kann sagen,
das muss dann kürzester Fahrt von Vina VJ sein.
Kurze Begründung von der Idee her,
wenn es irgendwie einen kürzeren Pfad gäbe als den,
der auf diesem Pfad liegt von Vina VJ,
dann könnte ich ja dieses VIVJ-Stück rausnehmen und das durch den anderen ersetzen.
Und dann müsste es günstiger sein. Das ist so grob
die Idee, wenn man das genau beweisen will,
da muss man sich noch so ein bisschen Gedanken machen.
Ja, aber was ist denn jetzt,
wenn dieser neue kürzeste Pfad plötzlich irgendwas nimmt von dem Pfad,
wo ich es gerade ausgeschnitten habe,
dann wird es nicht gehen, das da einfach einzubauen,
weil ich dann irgendwie zweimal rübergehe,
dann ist das kein Pfad mehr oder so
Da muss man sich einmal kurz Gedanken machen, ob das passiert oder so.
Aber so von der groben Idee ist es das eigentlich schon,
dass man sagt, naja, wenn es was Kürzeres gäbe,
dann kann ich das einfach substituieren.
Ja, so, und jetzt kommt gleich der Deikstra-Algorithmus,
da nochmal die Anmerkung, dass wir nicht mit negativen Gewichten
arbeiten und den hier wollen wir auch noch machen,
Bellman Ford, der erlaubt negative Gewichte.
Und das hier kennen wir ja schon, P von V.
Für die Vorgängerfunktion.
Setting, klar
Gut, dann brauchen wir zwei Hilfsfunktionen,
die eine ist ganz einfach, das ist so die Innet-Funktion,
dass man sagt, ich habe eine Quelle S,
also ein Startknoten-S hier und jetzt setze ich halt bei allen Knoten die Distanz,
die ich bisher ermittelt habe zu diesem Knoten, auf unendlich,
weil ich halt noch keinen kürzesten Vater hin kenne und seinen Vorgängerknoten auf null,
weil ich da eben auch,
ich habe den Knoten noch nicht entdeckt,
also gibt es noch keinen Vorgängerknoten,
also kenne ich auch noch keinen Weg dahin,
also es sind die Kosten unendlich und dann sage ich eben beim Startknoten,
da setze ich diesen Wert auf null,
also der eine Knoten,
das wird nachher der einzige Knoten sein,
der keinen Vorgänger hat und der
den Wert null hat
Was ist denn, genau, das ist der Startknoten,
das sind alle anderen. Und dann gibt es diese wichtige Funktion,
diese sogenannte Relax-Funktion, die eben das macht,
was wir eben auch schon im Beispiel gesehen haben.
Joben kann man das ganz gut sehen,
wenn man irgendwie den Knoten U schon entdeckt hat.
Bei dem ist man gerade, Entschuldigung, bei den Knoten U ist man gerade.
Und V hat man irgendwie schon entdeckt, hat ihn aber
noch nicht bearbeitet. Dann führt diese Relax-Funktion dazu,
dass man sich eben die beiden Knotengewichte anguckt und das Kantengewicht hier.
Und wenn dann eben der Wert von dem Knoten
hier die 5 plus die 2 kleiner ist als das,
was bei V steht,
dann setze ich das eben um
Und wenn es nicht kleiner ist, hier 5 plus 2
ist nicht kleiner als 6, dann setze ich es nicht um.
Dann würde ich sagen, es ist weiterhin günstiger,
zu V über den irgendwann vorher schon entdeckten Weg zu gehen,
der mich sechs kostet, als über den neuen jetzt,
der mich sieben kostet.
Und das ist das, was hier bei der Relax-Funktion entsteht
, passiert. Da wird halt geguckt,
was der Distanzwert von V und ist der größer als DU
plus das Kantengewicht und falls das der Fall ist,
setzt sich DV eben um und setzt seinen Vorgänger auf U.
Und das ist bei der Funktion,
also die wird dann aufgerufen, wenn man dabei ist,
U abzuarbeiten und wenn V irgendein Knoten ist,
den man eben schon entdeckt hat
Ja, oder auch wenn man den noch nicht entdeckt hat
, dann ist der Wert halt unendlich.
Wenn hier unendlich steht, macht das ja auch nichts,
dann ist U plus zwei immer kleiner als unendlich und dann
wird es auf jeden Fall neu gesetzt.
Ja, und damit kann man halt den Algorithmus machen,
sieht dann so aus. Am Anfang diese Initialisierung,
dann S sind halt die abgearbeiteten Knoten. Und genau,
dann tut man wieder alle Knoten des Grafen in die Q
und solange die eben irgendwie irgendwie nicht leer ist,
nehme ich immer das Minimum.
Das ist wieder irgendwie so eine Minimum-Prioritäts-Q oder sowas,
nimmt man wieder den Kopf der Liste
Sagt dann hier, dass man den abgearbeitet hat in Zweite
6 und dann passiert eben hier diese Relax-Funktion, ne?
In den Zeilen 7 bis 12,
dass man dann eben alle Nachbarn von U durchgeht und immer guckt,
ob man relaxieren kann.
In den Zeilen 8 bis
Bitte? Äh, nee, da wird nicht, ja,
also, da ist sie, um sie zu illustrieren und das,
was hier steht in den Zeilen 1 bis 4,
findet man jetzt eben hier wieder mit den Zeilen 8 bis 11. Genau,
hätte man jetzt auch einfach hinschreiben können, Relax,
V-U-W oder so, ne,
aber ja.
Sonst noch Fragen. Zum ersten, mein Gott.
Genau, das ist Dixtra. Am Beispiel vom Graphen,
wenn jetzt das hier wieder der Startknoten ist, Ganz links.
Kann irgendwie ein beliebiger sein, ne? Kriegt man halt irgendwie
andere Sachen raus. Aber fangen wir mal bei dem an.
Dann guckt man sich jetzt irgendwie seine Nachbarn an.
Der hat jetzt nur zwei hier, den links oben und den links unten hier.
Und dann werden die eben auf zehn und fünf gesetzt. Und dann ist der abgearbeitet,
jetzt hier durch das Grün, markiert und die dicken Pfeile hier,
die zeigen quasi die P-Funktion an, dass man jetzt irgendwie weiß,
sein Vorgänger ist der Knoten, der mit null markiert ist.
Und er glaubt auch, dass sein Vorgänger bisher der ist,
der mit null markiert ist.
Und jetzt wird eben der günstigste genommen.
Hier steht ja immer, dass das Minimum genommen wird in
der fünften Zeile
Lasst dann eben der Knoten mit der Fünf.
Und jetzt wird wieder alles durchgegangen, alle seine Nachbarn.
Und jetzt hat er als Nachbarn irgendwie alle Knoten außer den Startknoten und dann wird immer geguckt.
Hier ist irgendwie 5 plus 9 ist 14,
das ist kleiner als unendlich, 5 plus 2 ist 7,
das ist auch kleiner als unendlich.
Also die beiden werden auf jeden Fall neu gesetzt.
Und hier passiert halt das Interessante, dass irgendwie geguckt wird,
ist 5 plus 3 kleiner als 10 ist es,
also wird das neu gesetzt.
Dann sieht das so aus. Und hier passiert jetzt eben auch,
dass diese Kante umgelegt wird,
dass irgendwie das auf 8 gesetzt wird und gesagt wird,
jetzt ist sein Vorgänger nicht mehr S,
sondern eben der Knoten links unten.
Ja,
jetzt ist der günstigste R hier mit den
Und der wird nicht neu gesetzt mit der Null,
aber der hier wird neu gesetzt. 7 plus 6 ist 13,
das ist kleiner als 14, wird das neu gesetzt.
Jetzt der günstigste der Achter und jetzt wird er nochmal
neu gesetzt auf den Wert 9 und dann wird von dem
nichts Neues mehr entdeckt und dann sind wir fertig.
Die dicken Balken geben jetzt eben irgendwie die kürzesten Wege an
Dann, der kommt jetzt ja nicht mit negativen Gewichten klar.
Wenn hier bei dem Knoten rechts unten mit der Sieben,
wenn an der Kante hier nicht sieben dran geständen hätte,
sondern irgendwie minus acht, dann wäre es halt günstiger,
jetzt die zu nehmen, um irgendwie zu dem Essknoten zu kommen.
Dann weiß ich irgendwie, dass sie das ein kürzester Weg, um irgendwie zuerst zu kommen.
Dann habe ich aber irgendwie noch ein ganz anderes Problem,
dann habe ich ein negatives, negativen Kreis,
dann würde ich den irgendwie beliebig oft langgehen und kann irgendwie beliebig günstig werden.
Das will ich vielleicht gleich auch noch ausschließen,
aber so von der ersten Idee mal würde man sagen,
der kommt nicht mit negativen Kantengewichten, klar.
Und wenn man jetzt einen konstruiert, der mit negativen Kantengewichten klarkommt,
dann muss man nicht nur darauf achten,
dass man darin kürzte Pfade ermittelt, sondern vor allem auch darauf,
dass da keine kürze Kreise mit Kreise mit negativem Gewicht drin sind,
weil man die halt beliebig oft entlang gehen könnte.
Das will man jetzt ausschließen. Und das macht dieser
Bellman Ford Algorithmus. Da hat er da, genau,
in der letzten Zeile, der Algorithmus liefert Fords zurück,
sollte ein Zyklus mit negativem Gewicht existieren.
Kennt den einer? Weil es eine wieder funktioniert?
Das merken wir dann. Wieso jemand negative Gewichte dran schreiben
wollen würde, weil er das in seiner Modellierung braucht.
Wenn er zum Beispiel, warte. Ja,
dachte ich auch gerade, irgendwas mit Geld und dann sind
es Kosten oder so
Und da habe ich negative Gewichte. Wenn ich vielleicht weiß,
irgendwie, ich muss zwei Reifen kaufen,
um mein Fahrrad zu bauen, dann kommen da irgendwie richtige Gewichte,
also positive Gewichte dran und dann weiß ich bei einer anderen Stelle,
für irgendwas kriege ich aber Geld und dann geht das,
ist das ein negatives Kantengewicht.
Also irgendwie so Produktionszyklen, einem fällt bestimmt noch sinnvolleres ein,
wenn man länger darüber nachdenkt,
aber sinngemäß, wenn du irgendwas modellierst,
wo du es brauchst
Wenn man das größte negative Gewicht kennt, könnte man
alles nach oben schieben. Genau, ist mir klar,
wenn du jetzt irgendwie minus 10.000 das negativste Gewicht hast,
sondern dir hast du einfach zu allen Kanten 10.000 und 1
dazu oder irgendwie sowas.
Geht nicht, weil... Dreiecksungleichung wird verletzt, ne?
Also wir machen hier, zwei Pfade sind 13,
eins und zwei.
2.2 ist erfahren und
der andere Vater ist ein Bein
Wir müssen natürlich die Feier kosten, die Geister,
2. Vers 2. Vers 2. Vers 2. Vers 3. Vers
3. Vers
Also ich würde sagen, wenn du einen Vater hast,
der, nehmen wir mal das zwei Kanten, ne,
drei und minus fünf. Jetzt würde rauskommen,
wenn ich den entlang gehe, meine Kosten sind zwei.
Wenn jetzt bei beiden sechs dazu addierst, weil du sagst,
du willst keine negativen Gewichte haben, dann hast du einen Vater,
der neun kostet und der andere Vater eins kostet.
Jetzt wäre die Aussage dann, der kostet zehn.
Du machst es halt
nur damit
Ja. Ja. Ja, genau. Aber jetzt hätte man ja zehn abgezogen.
Ich frage mich gerade, ob das so einfach geht,
wenn man... Der hatte das Gewicht zwei, ne?
Drei und minus fünf. Wenn ich jetzt sechs
drauf addiere, habe ich neun.
Eins kommt irgendwie zehn raus
Jetzt müsste ich ja irgendwie, um auf das Ursprüngliche zu kommen,
müsste ich irgendwie, muss man, ach da.
Ah, ja. Das ist gut. Okay,
und dann könnte ich, genau,
dann habe ich zweimal sechs drauf verliert,
dann könnte ich die abziehen und dann habe ich das Gleiche,
ne?
Mhm. Es gibt einen Grund, warum man das nicht
macht. Ich frage mich gerade welchen.
Und dann
Und fährt ist das Innere. Zwei Tage, zweimal.
Das ist so merke, das ist so merke,
das ist so merke. Nee, aber ich kann noch,
also macht das nicht kaputt, oder?
Nö. Warte, warte, warte, warte,
warte. Diktier mal langsamer. Was soll ich meinen
Nein, das Leben. Wenn ich jetzt noch
alle zehn agiere, dann ist noch einer. Stimmt,
wenn ich jetzt irgendwo anders noch eine Kante habe,
die gerade nichts damit zu tun hat,
die irgendwie minus neun kostet und deswegen erdiere ich jetzt überall zehn dazu,
dann habe ich hier zwei,
die plötzlich elf kosten und er kostet 13. Und jetzt wird
der plötzlich günstiger,
ne?
Ja. Mich überzeugt, überzeugt es dich auch?
Ja. Schade. Da hätten wir fast Bellman vor Ort um seinen Algorithmus gebracht.
Wobei ich glaube, auch sonst wäre es wahrscheinlich nötig,
zumindest vorher zu wissen, ob es negative Kreise gibt.
Und das erwischt Bell mit Vorurteil, währenddessen kriegt er das schon raus.
Also die Bayman Ford Algorithmus kriege ich raus,
ob es negative Kreise gibt
Eingesetzt. Nee, ich glaube, ich müsste negative Kreise
ausschließen, weil dann fliegt mir eh alles auseinander.
Also wenn ich negative Kreise habe, will ich ja nichts machen.
Ja, genau, aber du willst ja nicht nur wissen,
ob es ein negatives Gewicht gibt. Davon gehen wir jetzt mal aus,
dass da irgendwie negatives Gewicht im Grafen ist,
sonst brauchen wir das Ganze ja nicht machen.
Aber dann willst du noch wissen, ob es irgendwo negative Kreise gibt,
weil wenn es welche gibt, gibt es eh keine kürzesten Pfade.
Und das würde man gar nicht mehr rauskriegen,
wenn ich überall was drauf verdiere,
weil den gibt es ja keine negative,
dann gibt es ja keine Kreise mehr,
also keine negativen Kreise mehr
Ja, genau, aber ich will wissen,
ob es negativ, also ja, dann gibt es was anderes,
aber dann kann ich das Ergebnis ja nicht mehr übertragen,
das ist ja doof.
So. Wie macht er das? Oh ja.
Also kennt ihn einer, Bellman vor Ort?
Bellman vor Ort. Bellman vor Ort ist so ein bisschen,
das sieht so Brut-for-Style-mäßig aus, weil der,
am Anfang macht er ein Init, das ist okay,
das kennen wir.
Und dann geht er hier Anzahl der Knoten minus eins mal
, einfach alle kannten durch.
Also hier, das ist ungefähr Anzahl der Knoten oft
Und da geht er alle Kanten durch. Und für jede
Kante guckt er immer, ob er sie relaxieren kann.
Das sieht irgendwie sehr gut forestyleartig aus. Also einmal
alle Kanten durchzugehen und zu relaxieren, das ist okay.
Da kann man sich schon vorstellen, da kann nicht sonderlich viel passieren,
weil die meisten Knoten ja gerade mit unendlich bewertet sind.
Wenn ich zwei Knoten habe, die mir unendlich bewertet sind,
dann wird da nichts passieren beim Relaxieren,
weil unendlich plus irgendwas kleiner als unendlich, nee, da funktioniert nichts.
Sondern das breitet sich nachher auch so vom Startknoten irgendwie aus aus.
Und dann macht er das Ganze aber hier irgendwie so oft,
wie er Anzahl Knoten hat, beinahe minus eins,
weil die Idee ist,
wenn danach ich das quasi noch einmal machen könnt,
hier unten passiert nämlich nichts anderes, als nochmal diese Bedingung im Relaxieren zu testen.
Hier gehe ich quasi, im Grunde genommen mache ich das,
was ich in den Zahlen 3 bis 5 gemacht habe,
mache ich das hier unten noch ein weiteres Mal.
Und die Idee ist aber, wenn ich irgendwelche Kanten en-mal relaxieren kann,
wobei ende jetzt die Anzahl der Knoten ist,
dann habe ich einen Kreis mit negativem Gewicht.
Deswegen ist sie auch diese Abbruchbedingung mit Return falls,
wenn nachdem ich das hier schon so oft gemacht habe,
dass immer noch möglich ist, das einmal zu machen,
dann muss ich einen negativen Kreis haben,
sehen doch gleich
ein Beispiel
Problem, wenn man den illustrieren will, ist,
man muss hier irgendwie für die Kanten,
muss man irgendwie angeben, wie die durchwandert werden,
weil je nachdem, wie man die durchwandert,
sieht das Beispiel anders aus.
Und hier, Beispiel, das so ähnlich aussieht wie eben,
nur mit negativen Kantengewichten und unten steht, wie die Kanten durchlaufen werden.
Warum ist das wichtig? Weil jetzt wird quasi,
es soll ja endminus eins mal, sollen diese Kanten jetzt durchgelaufen werden.
Wenn die so aufgebaut sind wie hier,
dann kommen hier jetzt absichtlich diese beiden Kanten,
die vom Startknoten ausgehen,
ganz zum Schluss
Wenn die ganze am Anfang wären,
dann könnte ich danach die Kante TX auch sofort relaxieren.
Noch beim ersten Durchlaufen. Dann würde ich beim ersten Durchlauf
zuerst diese beiden Kanten, die vom Startknoten ausgehen, relaxieren.
Dann habe ich hier einen neuen Wert. Und dann könnte ich
plötzlich hier auch relaxieren. Dann würde das beim ersten Kantendurchlauf schon passieren,
so wie es jetzt da steht, passiert es erst beim zweiten.
Genau, also wenn wir hier so durchwandern, TX,
das ist irgendwie die Kante, da wird jetzt gefragt,
ob unendlich plus fünf kleiner ist als unendlich, ist es nicht.
Dann bei TY wird irgendwie gefragt,
ob unendlich plus acht kleiner ist als unendlich und so weiter.
Also hier passiert die ganze Zeit nichts,
bis man irgendwie hier hinten bei ST und SY ist.
Und da wird halt geguckt, ob 0 plus sechs kleiner
als unendlich ist und 0 plus sieben kleiner als unendlich.
Das funktioniert
Genau, und jetzt wandert mal wieder die Kanten durch,
wo passiert jetzt was? Wo passiert zuerst was?
Ja. Genau, bei TX wird zuerst was,
passiert zuerst was, da wird dir auf elf gesetzt.
Bei TY passiert da was? Nee,
sechs plus acht ist nicht kleiner als sieben,
TZ passiert was
Und der hier YX passiert da war es. Ja,
ne, weil ich habe den zwar gerade auf 11 gesetzt hier,
6 plus 5 bis 11, aber jetzt ist 7 minus 3 ist 4,
4 ist kleiner als 11 wird er auch wieder gesetzt, ne.
Nur da seht ihr halt, dass es irgendwie schon davon abhängt,
in welcher Reihenfolge die Knoten sind, ne,
wenn das irgendwie andersrum gewesen wäre,
dann hätte man den hier auf 4 gesetzt und dann hätte man,
wäre hier eben gar nichts Neues passiert, ne,
wenn wir 11 nicht kleiner als 4, so passiert da nichts,
also hängt das sehr davon ab,
wie die Kanten gerade gegeben sind.
Die Worst-Case-Laufzeit lässt sich deswegen relativ schnell ermitteln, indem man irgendwie guckt,
naja, ich gehe da irgendwie eng mal für die Knoten
Hier gehe ich N mal rein in diese Zeilen 3 bis 5.
Und da rufe ich dann M mal was auf. Das heißt,
ich bin hier irgendwie im Worst Case N M M mal,
also Anzahl der Knoten, Anzahl der Kanten,
eine V mal E mal.
Im Worst Case. Aber so im Average Case und sowas
wird das Ding viel, viel besser sein, je nachdem,
wie die Kanten halt gerade angeordnet sind.
Ja, genau, das kam jetzt hier im zweiten Schritt
raus. Einmal, zweimal. Was wird jetzt noch verbessert
Ja, wo passiert noch was? Ja, genau,
bei XT hier. Der hat das Gewicht 4 und mit der
minus zwei Kante bin ich irgendwie bei zwei und dann ist
sechs kleiner als zwei, dann sieht das so aus.
Das war der dritte Durchlauf, wo passiert jetzt noch was beim vierten?
Genau, TZ hier, ne? Der hat das Gewicht 2,
der hat das Gewicht 2 tatsächlich auch sogar schon über die Kante.
Also wir wollen die sowieso schon nehmen
Aber jetzt merken wir halt nochmal, das ist auch ein bisschen fies,
weil das sieht so aus, als wäre die schon abgearbeitet.
Jetzt merkt man aber, ich kann die wieder relaxieren,
weil ich hier den WR2 habe, minus vier,
dazu addieren ist minus zwei,
dann wird der da auf minus zwei gesetzt.
Das war jetzt der vierte Durchlauf, ne?
Passiert jetzt noch was? Nachdem... Ja. Wenn es
gleich ist, dann würde der jetzt noch dazukommen,
ne?
Das wäre doof
Genau, so, also der mit den vier Malen war auch
schon aus dieser Hauptschleife oben raus und jetzt wurde nochmal geguckt,
ob ich jetzt noch irgendeine Schleife relaxieren kann,
irgendeine Kante relaxieren kann, kann ich nicht,
also bin ich fertig.
Und es gibt keinen negativen Zyklus, also es ist alles gut.
Jetzt habe ich hier kürzeste Pfade zu allen Knoten.
Tatsächlich ist das in dem Beispiel sogar nur ein Pfad,
das ist irgendwie S-Y-X-T-Z. Das ist... Ja,
und wenn das Gewicht hier jetzt kleiner wäre,
wenn das jetzt irgendwie eine Eins wäre,
dann würde ich jetzt sagen,
oh hier,
ich habe einen kürzeren Weg nochmal zu
Und dann hätte ich aber eben einen Kreis mit negativem Kantengewicht.
Deswegen wäre das okay, dann abzubrechen. Dann könnte ich nämlich,
wenn ich all diese Kanten entlang gehe,
habe ich dann irgendwie hier die sieben und hier habe ich minus drei,
minus vier, minus zwei und da dann eben die gedachten minus eins,
was dann eben zu minus acht führt.
Also habe ich irgendwie sieben, minus acht,
das minus eins, dann habe ich einen Kreis mit negativem Gewicht.
Dann wäre es also okay, da irgendwie abzubrechen.
Joa, da nochmal ein bisschen Anmerkungen,
dass wir eben die maximale Anzahl an Iterationen hatten,
die man so haben kann
Genau, und weil da nichts mehr zu tun ist,
sind wir fertig. Und wenn man jetzt aber die eine kannte,
dann auch irgendwie anders gewichten würde,
dann... Ich habe mich eben verzählt, ne?
Vier, minus drei, minus zwei sind minus neun.
Und wenn da dann der Einstände ist, mal bei minus acht, ja. Genau,
und da nochmal die Anmerkung zu den, warum so viele Iterationen da,
warum das genügt und dass man ansonsten eben schon maximale Zyklen hat,
nämlich Zyklen der Länge der Anzahl der Knoten entspricht.
Und die Laufzeit lässt sich ziemlich schnell ermitteln,
warum der korrekt ist, ist ein bisschen umständlicher zu zeigen,
hängt halt sehr stark mit dem dritten Punkt hier zusammen.
Genau, wollte ich jetzt aber nicht so in die Tiefe gehen bei dem.
Fragen dazu. Also der erste für kürzeste Pfade mit im gerichteten Graphen,
mit nur positiven Kantengewichten, der zweite langsamer als da extra,
aber kommt dafür mit negativen Kantengewichten zurecht und sagt Bescheid,
wenn es irgendwie negative Zyklen gibt.
Und der dritte, den wir jetzt nur ganz kurz antouchen wollen,
hier Floyd Warshall,
der löst diese vierte Variante,
also zu jedem Paar Zweierknoten
einen kürzesten Pfad zu bestimmen
Genau, und bei dem sind negative Gewichte möglich.
Problem ist, er kennt keine negativen Zyklen,
also so wie ich es da jetzt gleich aufgeschrieben habe,
er kennt er keine negativen Zyklen. Genau. Und für die,
die sich noch an diese Cleanie-Konstruktion erinnern, RJK,
aus dem FG1-Teil,
wo man irgendwie reguläre Ausdrücke in Automaten umgewandelt hat und Automaten in reguläre Ausdrücke,
das hier, das war ja so vom Zustand ZI
zum Zustand ZJ zu kommen und dabei nur die Zustände Z1 bis ZK zu benutzen.
Und sowas ähnliches macht man hier jetzt auch.
Man hat hier irgendwie einen Knoten, I hier einen Knoten,
J,
dann Knoten
Und diese D-I-J-K, die geben immer das Gewicht eines kürzesten Pfades an von dem Knoten-I zum Knoten-J,
wobei ich nur über die ersten K-Knoten gehe.
Und das Ziel ist nachher da oben überall ein Ende stehen zu haben,
dass man dann weiß, ich darf über alle Knoten rübergehen und halt kürzste Pfade von jedem Staat zum jedem Zielknoten zu ermitteln. Und das macht man dann so,
indem man sehr, sehr ähnliche Idee wie bei Clean,
dass man eben sagt, naja, das kürzeste,
oder das geringste Gewicht um vom Knoten-I zum Knoten-J zu kommen,
wenn ich nur über die ersten K-Knoten gehen darf,
dass es eben entweder,
wenn ich von I zu J gehe und da bei den Knoten K gar nicht benutze,
Oder wenn ich erstmal von I nach K gehe,
jetzt bin ich bei K und dann von K wieder zu J. Also entweder komme ich quasi direkt von I zu J,
ohne den Knoten K überhaupt zu benutzen.
Oder es ist eben günstiger,
von I zu K zu gehen und von da dann zu J.
Und dass hier diese Werte DJK,
die werden jetzt eben in so drei geschachtelten Vorschleifen sukzessive bestimmt.
Sieht dann so aus. K1 bis Ende durch den I1
bis Ende durchgehen J1 bis Ende durchgehen und dann werden die
hier immer bestimmt. Und wenn man nachher fertig ist,
dann hat man eben so eine Matrix,
wo die Dinger alle drinstehen
Also eine IMAJ-Matrix, wo die alle drinstehen und dann kann man da
einfach reingehen und weiß, was das geringste Gewicht ist.
Und parallel kann man, wenn man möchte,
eine Matrix aufbauen, die so ähnlich aussieht,
die dann eben was mit den Vorgängern zu tun hat.
Also so eine P-I-E-I-E-J-K-M-Atrix. Das ist der Floyd,
war schon, nur dass ihr den einmal gesehen habt,
dass ihr diese Art von Idee, dass ihr das nochmal irgendwie seht,
dass die in unterschiedlichen Kontontexten immer wieder auftreten.
Ja, da die Zusammenfassung. Der hier ist,
der ist klar, dass der NV hoch 3 läuft,
also Ende ist die Anzahl der Knoten,
also läuft er irgendwie in V hoch
The Amon Ford haben wir gesehen,
läuft in V mal E und da extra kriegt man
eben in V-Quadratin oder sogar in dieser besseren Laufzeit
da.
Ja. Adierst du gerade die Exponenten, oder was machst du gerade?
Aber warum? Das sind einfach nur irgendwelche Zahlenwerte.
Also D-I-J-K ist 4. Das sind und D-I-J. Nee.
D-J-K sagt D-J-Ksen wert. Das ist der Wert des
Das Gewicht des kürzesten Pfades von VI nach VJ,
wobei du nur auf diesem Weg von da nach da die Knoten V1 bis VK besuchen darfst.
Also du startest bei VI, jetzt kommen irgendwelche Knoten aus
Vereins bis VK, bis du bei VJ bist.
Ob das nicht weit in Konka-Algorithmus ist, Nee.
Nee, finde ich nicht. Können wir nochmal philosophisch drüber diskutieren,
aber ich finde nicht. Weil das nicht so richtig ein Teilproblem zerlegt wird und die dann einzeln gelöst werden,
sondern es wird ja mehr so iterativ aufgebaut,
dass ich irgendwann mal denke,
mein kürzestes Gewicht von V1 zu V3 ist jetzt irgendwie so und so und dann später widerrufe ich das und sage,
das ist jetzt irgendwas anderes und wie rufe ich das wieder und sage,
ist irgendwas anderes.
Sonst noch. Gut, dann sind wir auch fertig
mit den Grafen
Das war das, was wir alles so gemacht haben, zu Grafen.
Ein bisschen Grundlagen oder überhaupt die Datenstruktur erstmal aufzubauen,
dann Adjazenzmatrix, so eine Art Jazenzliste,
um eben die Grafen irgendwie im Computer zu speichern und damit arbeiten zu können.
Breitensuche, Tiefensuche, dann Anwendung der Tiefensuche,
das topologische Sortieren und Bestimmung starker Zusammenhangskomponenten und dann letztes Mal
ja hier minimale Spannbäume, Bestimmung der kürzesten Pfade.
Genau. Und nächstes Mal machen wir noch hier
die Flüsse im neuen Jahr.
Das war das zu den Grafen
Da die Anmerkung zur Literatur, dass sie das kaum noch mal nachlesen können,
vor allem hier in Kapitel 24 findet ihr halt ganz viel zur Korrektheit von DAX aus Algorithmus.
Das kann man sich mal angucken,
weil da relativ viel ja irgendwie intuitiv klar ist,
also zum Beispiel so bei dieser Relax-Funktion denkt man so,
ja, würde ich genauso machen oder so.
Und da stehen eben relativ viele Beweise für Dinge, die irgendwie,
die man recht schnell glaubt so und dann kann man sich
ganz gut mal in die Beweise reinlesen und irgendwie gucken,
ah ja, okay,
so müsste man da Schritt für Schritt für Schritt irgendwie aufbauen,
damit das irgendwie tatsächlich als korrekt nachgewiesen wird.
Genau,
da kann man gut mal lesen
So, das haben wir gemacht hier, minimale Spannbäume gegeben,
so ein ungerichteter Graf in dem Beispiel und in dem Fall und eine Gerichtsfunktion wollten wir einen Spannbaum haben,
also einen Baum,
der alle Knoten enthält und dessen aufsummierte Kantengewichte möglichst gering sind und die beiden Verfahren,
die wir da kennengelernt haben, waren eben Kruskal und Prim,
da sind die nochmal, Kruskal war ganz einfach,
immer unter allen Kanten, die mit dem kleinsten Gewicht nehmen,
also von der Idee ganz einfach, von der Implementierung schwieriger,
das war so diese Idee mit den Datenstrukturen für das jungte Mengen und sowas,
die man da noch brauchte.
Genau, und dann Prim,
den haben wir eben nochmal gesehen
Das war das. Und kürzeste Pfade haben wir jetzt heute
die ganze Zeit gemacht. Das ist nochmal die Problemstellung fürs
Nachbereiten. Und da die Zusammenfassung. Fragen zu den Grafen
. Gut. Dann die letzte halbe Stunde sinnvoll auszufüllen.
Was würdet ihr sagen, ist zentral in der Vorlesung
Keine Meldung. Ja. Komplexitäten, ja, schön.
Das ist keine andere Meinung zu dem Thema gibt.
Ja, was machen wir denn die ganze Zeit?
Wir sitzen hier und hören zu, du erzählst.
Mathe, ja, ich bin genau über meine Mathe.
Ich habe mir immer gestern, ja, Oh ja, Entscheidungsprobleme.
Jetzt streiche ich mir noch das Entscheidung weg und dann haben
wir Probleme. Wir lösen eigentlich die ganze Zeit Probleme.
Wir fangen irgendwie an, haben angefangen mit irgendwie Suchen.
Dann haben wir gesagt, bei dem lineares Suchen war klar,
irgendwie so Brut Force alles angucken.
Dann haben wir gesagt, okay, machen wir binäres Suchen.
Dann haben wir festgestellt, binäres Suchen ist schneller,
aber alles muss sortiert sein. Dann haben wir gesagt,
okay, dann sortieren wir halt so. Dann haben wir
uns da Tieralgorithmen angeguckt. Irgendwann später sind wir nochmal zurückgekommen
zu binären Suchbäumen. Und dann haben wir irgendwann gesagt,
okay, das haben wir so dieses Thema so ein bisschen abgefrühstückt.
Aber das funktionierte ja alles nur, wenn man quasi auf
den Objekten wenn die irgendwie so unidirektional verbunden sind.
Also wenn ich Zahlen habe und dann sage, okay,
diese Zahl, die hat einen Vorgänger, einen Nachfolger oder irgendwie sowas.
Also es war nicht möglich zu sagen, ja, habe ich die Zahl 15.
Und die steht mit der 18 in Beziehung, mit der Elf,
aber irgendwie auch mit der 12 und der 16 oder irgendwie sowas.
Das hat man höchstens hingekriegt, indem man gesagt hat,
wenn ich die so aufreihe, dann sind das alles Vorgänger oder irgendwie sowas.
Aber das ist jetzt nicht so das, was ich meine,
sondern ich meine, sowas wie beim Graphen eben,
dass man viele Elemente eben nicht nur einen Vorgänger-Nachfolger,
sondern dass man irgendwie sagen kann, dieses Element ist mit zehn anderen irgendwie verbunden.
So kommt man dann irgendwie zu Graphen. Und
auch da haben wir uns dann wieder so Sachen angeguckt,
wie irgendwie, wie durchwandere ich das eigentlich?
Jetzt kann ich das halt nicht so wie so ein Array durchwandern,
sondern muss das irgendwie Breitensuche,
Tiefensuche machen
Und danach, auch da wieder sowas wie Sortierverfahrene,
so topologisches Sortieren, hatten wir da dann auch irgendwie,
aber im Zentrum stand immer ganz zentral,
zum einen Probleme und wie man sie löst natürlich.
Und zum anderen dann Laufzeitanalysen, was er gesagt hat,
so Komplexitäten irgendwie, dass man die Algorithmen auch irgendwie bewerten kann bezüglich ihrer Güte.
Ich habe ein Problem, ich will es lösen, jetzt habe ich was,
um was zu lösen und jetzt möchte ich die Güte davon bewerten.
Das, was wir gemacht haben, ist die Güte bezüglich
der Laufzeit zu bewerten. Und wenn man das macht,
wenn man jetzt auf der einen Seite sagt, okay,
jetzt bewerte ich diese Güte, jetzt brauchen wir noch etwas,
um sagen zu können, Die Güte, das ist Mist.
Das ist so ein Algorithmus, der das Problem löst, aber das ist Mist.
So, wenn das irgendwie ein Exponentialzeitalgorithmus ist. Gut,
sagt man, wenn es ein Pudding mehr als halt Algorithmus ist,
so probt. Je kleiner das Pudinomen, desto besser.
Und dann fing man wieder an und sagt, okay,
dann, wenn ich jetzt aber nur einen Mistalgorithmus habe,
also nur einen Exponentialzeitalgorithmus, dann möchte ich zumindest irgendwie eine Möglichkeit haben,
zu sagen, es geht nicht besser,
Auftrittkomplexität,
Auftritt so irgendwie NP-Vollständigkeit und sowas.
Aber zentral war quasi
Zentral, weil dieses Problem lösen und dann brauchten wir irgendwie
eine Möglichkeit, die Probleme überhaupt darzustellen.
Also mit Datenstrukturen. Jetzt kann man sich so überlegen,
was haben wir da alles so gehabt?
Da haben wir irgendwie Arrays, Arrays ist noch irgendwie
sehr,
sehr einfach
Ja. Arrays und elementare Datentypen gehabt. Dann haben wir
gesagt, so was wie Stack, Q. Verkettete Listen.
Was fällt euch noch ein? Was haben wir
noch gehabt? Peeps. Hiebsbäume. Grafen
Bäume, Suchbäume, spezielle Bäume, ne? Diente alles dazu,
die Daten irgendwie auf eine bestimmte Art und Weise anzuordnen.
Und sie irgendwie in der Bearbeitung zugänglich zu machen, so,
ne? Dass wir irgendwie dieses Ding mit Probleme darstellen.
Und dann haben wir uns, wie gesagt,
ganz viele Probleme angeguckt, so.
Und das erste, was wir uns angeguckt haben,
war irgendwie suchen. Dann haben wir irgendwie lineares,
lineares Suchen gemacht
Binäres Suchen, suchen mit Suchbäumen,
schreiben wir es auch nochmal hier hin.
Beim Beanie entsuchen haben wir festgestellt, wir wollen sortieren.
Da hatten wir dann, oh Gott, Bubble Sword,
Min Max Sword, Insearch and Sword.
Was hatten wir denn noch so
Was hatten wir noch? Genau. Ich glaube,
eins hatten wir noch. Eins hatten wir noch.
Eins hatten wir noch
Ja, das ist, glaube ich, Dings.
Das ist so Min-Max-Sord, so grob. Man kann auch ein anderes selektieren,
aber bei Min-Max selektierst du halt das Minimum oder Maximum.
Also Min-Sord oder Selection-Sord hier. Und der letzte? Ja
. War bis heute auch schon? Den habe ich mal
nicht aufgeschrieben, ja. Wir hatten noch ein schön schnelles
. Du hattest das quasi gesagt, wie hieß das?
Counting Sord, ne
Kann man nicht so einfach diese Schickschnelle. Und die hier
... Die waren ein ON-Quadrat, die hier waren in ON mal Login.
Ne, und Quicksault war so ein bisschen in beiden.
Ne. Je nachdem, ob man sagt,
du hast Case-Laufzeit, und das Quicksault nämlich eigentlich in UN-Quadrat,
aber so von der Idee her läuft das meistens ziemlich,
ziemlich schnell
Und hier haben wir irgendwie Counting Shot mit ON. Und
da hatten wir so diese Grenze, wo wir gesagt haben,
wir kommen eigentlich unter diese Grenze gar nicht runter.
Also unter dieses ON-Malogin, solange wir bei vergleichenden Sortierverfahren bleiben,
wenn wir aber nicht vergleichen,
eine vergleichende Sortierverfahren waren die,
wo ich immer irgendwie zwei Elemente rausnehme und bezüglich ihres Wertes
irgendwie vergleiche und dann dementsprechend irgendwie was mache
Bei den oberen Verfahren, hier passiert das immer.
Bei Countings Hot passierte das nicht. Da hat man irgendwie
die Elemente gezählt und damit was gemacht. Da hatten wir
also tatsächlich mal die Möglichkeit, eine untere Grenze zu zeigen.
Haben wir gesagt, sortieren geht gar nicht schneller als den
ON-My Login. Und haben sie dann eben trotzdem durchbrochen,
wobei wir da eben ein bisschen gemogelt haben.
So, jetzt kann man sich, sieht man da irgendwie,
die Verfahren, die sind alle schön.
Ach so. Rot-Schwarzbäume hatten wir auch noch
So ganz kurz. Genau, und jetzt haben wir da
die Grenze und jetzt kann man eben auch sagen, okay,
jetzt können wir irgendwie, jetzt haben wir verschiedene Probleme,
die wir lösen können oder die wir erst darstellen können und die wir dann lösen können.
Hier stellen wir aber schon fest,
wir haben irgendwie eine Grenze und das mit den Grenzen,
das wollten wir dann noch ein bisschen mehr formalisieren,
dass wir gesagt haben,
okay,
wenn wir das nur in dem Fall können,
können wir das vielleicht auch für andere Fälle und das
ist eben dann dieser Auftritt mit irgendwie PNP
Ja. NP, NPC und so. Und da waren eben
so Probleme drin, wie irgendwie satt. Independence Set,
Vertex Cover, was hat mir noch so Clique?
Und noch ganz viele weitere. Das sind so
sowohl irgendwie Probleme als auch welche, die sich nicht
gut lösen lassen
Jo,
was hatten wir noch?
Grafen mit den ganzen Algorithmen,
die wir jetzt eben so hatten.
Und was fehlt jetzt noch
Da habe ich vergessen. Hier so. Was haben wir
noch gemacht? Bei die weiten Konka-Verfahren fuhren fiel es ja
schon so irgendwie, die weiten Konka-Verfahren.
Was haben wir so ganz am Anfang der Vorlesung gemacht,
wo man so viel rumrechnen musste und so?
Genau. Was haben wir da gebraucht zur Analyse
Hier stecken ja überall Laufzeitanalysen drin.
Ja, kann man ja auch nochmal machen, ne?
Ich nenne das mal Techniken. Iterativ, rekursiv, Brutford
Die White and Conquer, Ready. Dass wir quasi eine andere Brille,
um darauf zu gucken, hier sagen wir irgendwie,
wir wollen Probleme lösen,
das sind ganz spezielle Probleme und wie lösen wir die?
Genauso gut hätte man noch so drauf gucken können,
dass man irgendwie sagt, mit welchen Techniken löse ich die?
Und dass ich dann die Techniken quasi lernen will,
um das zu machen. Den Blickwechsel machen wir nächstes Mal
nochmal. Und das, was jetzt noch gefehlt hat,
hier ist irgendwie Rekurrenzgleichung,
haben wir
noch gemacht
Und ich, habe ich jetzt alles? Ich glaube ja,
ne? Ja, das. Ihm fällt noch was ein?
Kurrenzgleichung, Suchbäume sind drin, rot, Schwarzbäume sind drin.
Ja, ich glaube, das war's. Und für euch zum,
malt euch mal selbst so ein Bild, wo ihr irgendwie draufschreibt,
was wir alles gemacht haben und wo irgendwie Verknüpfungen sind.
Also wenn ihr euch überlegt,
so dass im Zentrum irgendwie so Fragen sind wie,
Also eigentlich ist das Problem, das ist im Zentrum so.
Und dann gibt es davon so mehrere Abzweigungen,
dass man sagt, wie kann ich es darstellen, Thema Datenstruktur?
Wie kann ich es lösen? Thema, die einzelnen Sachen,
die wir hatten, um das zu lösen oder die Techniken,
die wir hatten, um das zu lösen.
Wie kann ich die Lösung bewerten? Laufzeit interessiert mich.
Laufzeitanalyse, Rekurrenzgleichung, sowas. Und dann da auch wieder,
okay, jetzt habe ich Technik, um das zu bewerten,
wie kann ich da Grenzen finden?
Thema NP-Vollständigkeit oder eben dieses eine Ding,
wo das ging mit untere Grenzen fürs Sortieren. Genau,
Probleme lösen, Probleme darstellen, Laufzeitanalysen und die Grenzen,
das sind so die vier Dinger,
die wir hatten,
die so zentral sind in der Vorlesung
Fragen. Ja. Nee. Die Frage war,
was davon wird uns im Studium begleiten?
Was davon wird uns Beruf begleiten sozusagen
Also, ich behaupte mal, jedem ein bisschen was, so,
ne, nicht jedem alles, aber jedem ein bisschen was,
im Studium auf jeden Fall, so, weil,
okay, es gibt, glaube ich, ein,
zwei Richtungen, wo man dann da ganz rausgeht,
also wenn man jetzt irgendwie vielleicht in so eine Richtung geht,
wo man sich eher um soziale Aspekte in der Informatik orientiert oder so,
dann wird das vielleicht keine Rolle mehr spielen oder so,
so Management-Aspekte oder irgendwie sowas,
da ist man dann da vielleicht ein bisschen sehr weit raus so,
ne, aber sonst ist es eigentlich egal,
ob du jetzt irgendwie einen Roboter programmieren willst oder eine künstliche Intelligenz oder ob du sagst,
du bist eine Datenbankanwendung schreiben oder,
ne,
ist echt ziemlich egal,
es treten überall immer irgendwelche Algorithmen und Datenstrukturen auf
Und ihr werdet jetzt eben nicht irgendwie losgehen müssen und irgendwie ein Quicksalt implementieren.
Also zumindest, das werden wohl die wenigsten machen müssen,
irgendwie losgehen müssen und ein ganz spezielles Verfahren, das es schon gibt oder so implementieren.
Was aber sehr häufig auftritt, ist,
dass ihr irgendwie eine Abwandlung davon implementiert oder dass ihr irgendwie sagt,
okay, mein Problem ist ja eigentlich ein Graf,
also drücke ich das irgendwie über Grafen aus und rufe dann eine Library-Funktion auf,
da muss ich aber, das muss ich irgendwie kennen,
sonst sehe ich das gar nicht.
Also wenn ich irgendwie ein Problem habe und ich kenne sowas
wie Grafen oder Bäume nicht,
dann sehe ich diese Struktur üblicherweise in meinen Daten auch nicht
und dann kann ich es so auch nicht ausdrücken und dann kann ich auch nicht mit Algorithmen darauf arbeiten,
die es vielleicht schon gibt,
dann finde ich das Rad irgendwie
x-mal neu
Genau, dann, also das meiste ist echt so Standard.
Also die ganzen Datenstrukturen, die ganzen klassischen Algorithmen,
die wir so machen, die treten immer mal wieder auf so.
Wichtig sind vor allem auch die ganzen Techniken, die dahinterstehen.
Und die begleiten dich dann nicht nur im Studium,
sondern nachher auch im Beruf so. Auch da wieder,
je nachdem, wo du dich hin entwickelst, so natürlich.
Aber dass man eben, wenn man vor einem algorithmischen Problem steht,
dann mal drüber nachdenkt,
vielleicht mache ich es mit die weit in Konka,
weil dann geht es schneller oder sowas,
sollte immer mal auftreten irgendwie
Also zumindest, ich sage es jetzt Alformation, ist bei den spannenden Jobs tritt das dann hoffentlich auf.
Also ich habe schon von Leuten gehört,
die dann gesagt haben, die programmieren auch,
aber die dann sagen irgendwie, ich bin ja so froh,
wenn ich mal eine Vorschleife implementieren darf,
da habe ich richtig das Gefühl, ich programmiere mal wieder,
weil sie ansonsten irgendwie quasi in der Innenhouse-Dokumentation auch nur nachgucken,
welche Library-Funktionen sie aufrufen oder irgendwie sowas.
Solche Jobs gibt es natürlich auch sehr, sehr viel so.
Es ist immer so ein bisschen,
ich finde das dann immer nicht so wirklich spannend.
Das ist dann so ein bisschen so, ja,
ich weiß, es gibt gutes Geld und so,
aber das
Ja, genau. Einmal, wir müssen ja wissen,
überlegen. Kann man das nicht irgendwie weniger martialisch machen?
Gibt es doch bestimmt was Friedliches. Ja. Nee,
also tatsächlich ist es so,
bei anderen Vorlesungen ist es schwieriger zu illustrieren,
wo der Anwendungsbezug ist, bei Algorithmen und Datenstrukturen,
wie es eigentlich immer recht einfach, was man da sagt,
so Algorithmendatenstrukturen treten eigentlich immer auf.
Und sei es im Jobinterview. Ja,
dann müsste es zumindest fürs Jobinterview wissen.
Sonst noch Fragen
Gut, dann bin ich fertig für heute, also so ganz fertig für heute.
Es sei denn, ihr habt jetzt noch irgendwelche Fragen.
Das kannst du gerne abfotografieren, aber ich würde dir eher empfehlen,
es selbst zu machen. Also du kannst natürlich abfotografieren,
ich würde jetzt auch nicht meine Hand dafür ins Feuer legen,
dass da nicht irgendwo Don noch ein Buzzword fehlt oder so,
aber der Sinn von sowas ist eigentlich eher,
dass du dir das selbst machst,
weil du es dann quasi so aufbaust,
wie eben irgendwie deine Gedanken auch im Kopf
sind und das hilft dir mehr
Ja, aber das ist ja gut, wenn dir das hilft,
um das alles so im Kopf zu behalten, ist doch super.
Sonst fotografierst du halt ab und lernst, versuchst es genau so zu lernen,
aber ob ich, ob sie es jetzt irgendwie da und da stehen,
hast du da eine Kante zwischen, hast du da nicht so, das ist halt eher so für deinen Kopf. Also cool wäre halt,
wenn ihr euch dabei überlegt, dieses,
was ich versucht habe zu illustrieren, so Probleme lösen,
Laufzeitanalysen, solche Sachen, dass man so weiß,
so das sind irgendwie die wichtigen Sachen so,
kann man auch irgendwie anders drauf gucken,
man kann auch irgendwie sagen, für mich ist das Wichtigste,
die Techniken, wie löse ich neue Probleme oder irgendwie sowas,
dann guckt man da vielleicht anders drauf,
dann klassifiziert man das nicht nach Sortieren und Suchen,
sondern sagt, vielleicht das sind die Spannenden,
die weit in Konka-Verfahren, die wir hatten,
das sind die spannende Greedy-Verfahren,
die wir hatten und klassifiziert die ihr so nach den Technik,
die dahinter stehen oder so
Oder dann eben, wo du vorhin meintest, Floyd Warsteller,
ob das sowas ähnliches ist wie die Weite und Conquer,
dann könnte man vielleicht sagen,
so bei seiner Mindmap macht man das so,
dass man sagt, so,
das gehört so ungefähr grob in die Ecke oder irgendwie sowas, ne?
Ist okay. Jo. Dann, zum ersten, noch Fragen,
zum zweiten, noch Fragen, zum dritten, noch Fragen.
Dann wünsche ich schöne Weihnachtsferien und chillt mindestens eine Woche am besten zwei und
wir sehen uns dann in neuer Frische am 6. Januar,
glaube ich, ne?
Alles klar,
dann bis dahin