Gut. Die Idee ist jetzt ja,
dass wir nochmal so ein bisschen abschließen zu dem Thema Parallelität und Algorithmen und Datenstrukturen,
haben ja, wie ich schon mal gefragt habe,
die meisten von euch schon gehört oder haben es jetzt gerade gehört.
Das heißt, da geht es ja auch um diverse Aspekte von
dem Design und Aufbau von den Algorithmen und Betrachtungen zur Komplexität.
Und genau das ist hier natürlich jetzt auch eins der Themen,
was wir uns jetzt angucken.
Und dabei machen wir jetzt genau das,
was dort sozusagen als Advanced Topic sozusagen ausgeklammert worden ist,
nämlich die Parallelität so ein bisschen mit rein
So, das Modell, was dahintersteht, sind ja die P-Rams,
das sind, die wir irgendwie programmieren wollen, das war das,
was ihr ja alles bei Herrn Falk ausführlich gehört habt.
Die Idee ist jetzt, also so einen kleinen Einstieg kriegen und
im Grunde genommen ist das jetzt nur irgendein Beispiel und naja,
mehr oder weniger Appetit anregend,
sich mit diesem Thema in Hauseinander zu setzen.
Es zeigt einfach nur, in welchen Größenordnungen sich Dinge bewegen können,
wenn wir Richtung Paralität gehen können, was aber,
wie ja auch erzählt werden worden sein dürfte,
dass nicht jeder Algorithmus sich beliebig verschnittern lässt durch mehr Hardware
So, und das heißt, dann ist natürlich auch gerade
da dann wieder die Frage, wie man solche Gut designt.
Aber das ist jetzt hier nicht das erste Thema,
sondern hier geht es wirklich erst mal nur um die prinzipiellen Dinge dahinter und so ein paar Möglichkeiten,
die man dann in dem Kontext einsetzen kann.
So, parallel sortieren war dann das Haupt,
die hat Augenmerk jetzt hier mit dem parallelen Algorithmen,
Darstellung ist Pseudocode und naja,
irgendwie sollten wir das immer in so eine P ran
in vernünftiger Zeit bekommen
Und die Idee war dann halt, dass man von diesem Teil,
wir haben einen Speicher und einen Prozess oder so einsam
auf diesen riesen Speicher arbeitet, machen wir das so,
dass da mehrere auf diesen gemeinsamen Speicher arbeiten.
Womit ich mich persönlich noch beschäftige, sind Algorithmen,
die sich im verteilten Fall auch noch bewegen.
Das heißt, wir haben auch noch viele Speicher,
wir haben uns sowohl gemeinsam Speicher als auch verteilten Speicher
und dann kommt nochmal sozusagen eine Stufe obendrauf.
Also das, womit wir uns auch beschäftigen werden.
Nächstes Semester ist bei euch nicht ganz so spannend.
Gibt es dann im Masterstudium eine extra Vorlesung von Herrn Falk
zum Thema verteilte Algorithmen
Und diese verteilten Algorithmen werden sich also im Wesentlichen darum kümmern,
wie man die Algorithmen, auch wenn sie verteilt sind, sozusagen betrachten kann.
Dann kommst du durch die Nachrichtenlaufzeit, auf die Anzahl der Nachrichten,
auf alles Mögliche kommt es dann darauf an.
Und da können wir noch ein bisschen weiter graben. Das heißt,
wir sehen jetzt aber hier erstmal ein einfaches Modell,
was in Bezug auf die Algorithmen schon in keiner Weise mehr
eigentlich als einfach einzustufen ist, jedenfalls nicht für Drittsemester,
wobei halt den gemeinsamen Speicher nehmen und uns dann um die Programmierung dieser entsprechenden Prozessoren kümmern wollen.
So, und da hatten wir entsprechende Gerücken und Laufzeiten für die Gruppensequenziellen sortieren.
Und das entsprechende ist dann die Frage jetzt,
was passiert hier bei der Parallelität? Und naja,
das Spannende ist, dass es halt ein bisschen schneller geht.
Und dieses bisschen ist halt immer relativ,
weil es sozusagen zum Beispiel US-Elugrhythmus ist von diesen Dingen hier oben,
was eben erfordert, dass man, um da hinzukommen,
diese Teile hier entsprechend sinnvoll umgestalten muss.
Und zwar in der Form, dass man halt auch in diesen Bereichen auch wirklich bleibt.
Dann war die Frage nach optimalen Algorithmen die immer noch wieder dabei ist.
Und da ist halt die Anzahl der entsprechenden Operationen wieder mit dabei.
So, und die Prozessoren, ja,
da können wir jetzt eben nur N nehmen.
Wir könnten noch ein Quadrat oder noch viel mehr nehmen,
je nachdem, wie das ausschaut.
Die Frage ist halt, haben wir, wie viele Prozessoren?
Wie viele Prozessoren haben wir eigentlich zur Verfügung?
Und das ist ja so prinzipiell die Idee,
dass man darauf achtet,
dass man sozusagen nur eine begrenzte Anzahl von Prozessoren in Anbetracht
der dann zu verarbeitenden Datenmenge hat
Wenn ich für jede einzelne Adresse einen eigenen Prozessor hätte,
sehe ich das schon wieder ganz anders aus,
wenn ich 100 Millionen Adressen irgendwie verwalten möchte,
ob ich dann so viele Prozessoren dafür habe,
ist die nächste Frage.
Also die Frage ist, wie viel N haben wir denn dafür?
Und das Spannende ist ja, dass die Anzahl der Prozessoren,
die uns tatsächlich zur Verfügung stehen, kontinuierlich steigt.
Und vor dem Hintergrund ist das dann hier durchaus eine spannende Frage,
wie man mit Hilfe dieser Prozessoren,
das sozusagen dann nach oben bekommen kann
So, dann bezüglich Wachstum haben wir so eine Tabelle hier gehabt,
wobei die, ich sag mal, ich will jetzt nicht ungenügend,
aber nicht wirklich hilfreich ist zum tatsächlichen Aufzeigen,
wo es hingeht, weil diese Faktoren werden natürlich dann besonders spannend,
wenn es richtig große Zahlen sind und nicht so kleine,
wie wir es hier vorne nehmen,
aber das könnt ihr euch selber überlegen,
wie das entsprechend wächst.
Sollte ja auch schon aus der Schule herkennen eigentlich. So,
das heißt, diese Größenordnungen sind durchaus spannend,
dass man in diese Kategorien reinläuft und nicht da oder zu einem Quadrat oder sonst irgend sowas.
Man trifft also immer möglichst klein zu werden.
Ist nur relevant, wenn es sich um Problemstudien kennt,
wo man wirklich viel verarbeitet
Wenn eure private Adressdatei sortieren wollt, dann würde ich sagen,
nehmt ihr einen einfachen Algorithmus und packt das da rein.
Und dann seid ihr im Normalfall hinreichend schnell dabei.
Spannend wird es aber eben, wenn man eine Million von Datensätzen
da arbeiten möchte. Und dann ist schon die Frage,
wie man das dann sinnvoll organisiert. So, und naja
, ein Quadrat ist dann halt noch schlimmer.
Einige, die schlimmer sind. Wie gesagt,
zur Erinnerung, Pitelnetze, wachs nicht primitiv rekursiv.
Also da ist das Endquadrat noch völlig harmlos gegen
Zwei Hoch-N ebenfalls. Also das sind dann Größenordnungen, die ganz schnell aufzeigen,
wie schlimm das sozusagen wird in Bezug auf die Zustände,
wie im Mittelfeld der Netze darstellen können.
Gleiche gilt aber auch für euer Java-Programm, das wächst genauso schnell sozusagen.
Also auch die anderen Dinge, die ihr habt. Ihr müsst also ständig mit dieser Riesenkomplexität leben und was macht ihr? Ihr strukturiert eure Programme in der Weise,
dass die Algorithmen nehmt und die so aufteilt,
dass sie bestimmte Anforderungen erfüllen, nämlich,
dass sie im Hinblick auf ihre Laufzeitverhalten, also auf die Dynamik,
die in dem Algorithmus dann drinsteckt, in dem Programmcode,
Das versucht ihr dann entsprechend so zu gestalten,
dass es sich in diesen Rößenordnungen bewegt und nicht irgendwo mit beliebig und Nhoch 3 oder irgendwelchen Geschichten,
wo ihr mal einfach eine Klammer, eine Schleife, dreifach geschachtelt,
drei Klammern sozusagen habt und da mal ein bisschen was rechnen lasst.
Sondern ihr versucht das sozusagen anders zu gestalten. Und das ist
sozusagen einer der Hauptpunkte, was man dahinter eigentlich macht.
Man gestaltet Strukturen, in denen sich hinterher Verhalten von Systemen zeigt.
Und das kann man eben in verschiedener Form sozusagen untersuchen und angucken.
Und genau dafür gibt es all diese feinen Log und N und irgendwas-Geschichten da drin,
um genau eine Orientierung zu haben, wie man das eigentlich strukturiert,
ob es sich noch lohnt für ein bestimmtes Problem oder ob es sich auf jeden Fall lohnt, so etwas zu tun.
Das ist die Hauptfrage dahinter. So und dieses Wachstum ist eben nur relevant,
wenn ihr in Kontexten seid,
wo das Wachstum auch wirklich euch schmerzen würde,
dann viel Gehirnschmalz in die Gestaltung von Algorithmen reinzustecken,
weil ihr, wenn ihr diese Strukturen schafft, natürlich,
um dann das entsprechende Verhalten auch hinzubekommen,
das werden wir nachher noch sehen,
schon einige Klimmzüge machen müsst,
um die Algorithmen dahin zu bekommen,
dass sie so gut in der Laufzeit
halt letztendlich werden
Und genau da drin steckt natürlich dann wieder eine Gefahr. Das heißt,
wenn ihr also diese Algorithmen sehr gut durchdesignt, habt ihr das Problem,
dass es, wenn ihr so guckt, ach,
das sieht ja eigentlich ganz klasse aus, aber die Frage ist,
ist es immer noch korrekt oder leistet es noch das,
was es tun will?
Weil es dann ein sehr komplexer Aufbau wird, wird dann
auch die Verifikation wieder schwieriger von diesen Dingen. Gut,
machen wir so einen Trade-Off haben,
was man eigentlich haben will, geht es,
um dass ich schnell irgendein Beispiel hinmale und schnell irgendwas ausprobiere,
dann versuche ich darauf zu bleiben oder möchte ich gern irgendwas effizient oder
sinnvoll durchgestylt als guten Algorithmus oder vielleicht auch didaktisch gut aufbereiteten Algorithmus sozusagen vorzeigen.
Und wo stecke ich da die Zeit rein
Diese Zeit reinstecken, geht in diese Algorithmen beliebig lang.
Das sieht man da dran, wenn man sich anschaut,
wie Matrix Mutiplikationen seit vielen, vielen Jahren ein Thema ist,
wie man das immer noch schneller bekommt und immer noch verbessern kann und so weiter.
Und da sieht man dann, welcher Aufwand in die Gestaltung
von solchen Algorithmen eigentlich hineingehen kann im Endeffekt. So,
und die Palette für euch ist von Bubble Sword oder einfache Schleifen bis hin zu den Dingen,
die da sind und dann alles,
was danach noch kommt,
was ihr dann vielleicht im Bereich Datenbanken oder sowas dann auch wieder gut einsetzen könnt,
je nachdem,
was ihr macht
Vorlesungen, Agrib und Datenstrukturen, Algorithmik und so weiter sind,
wie gesagt, Top-Adressen da für euch, um,
dass ihr euch genau sowas anschaut und euch dort nochmal erklären lasst,
wie diese Dinge funktionieren. Oder eben halt so verteilte Algorithmen,
wenn ihr für verteilte Systeme was aufbauen wollt,
wo ihr also Rechner habt, die von anderen so weit getrennt sind,
dass es dann eine lange Laufzeit von den Nachrichten entsprechend gibt und wir nicht über den gemeinsamen Speicher eine Synchronisation hinbekommen können.
Okay, Irgendwas mit Sortieren, naja, okay, jetzt,
was man sich zuerst einmal anguckt, sollte Herr Fall,
glaube ich, auch schon erzählt haben,
ist etwas zu parallelen suchen und mischen.
Das heißt, irgendwas muss ich auffinden und ich will irgendwelche
sortierten Listen haben und dann will ich die wieder mischen.
Und ja, dann wollen wir mal gucken, wie das jetzt geht.
Da gibt es halt die Mischung und da kommt man jetzt auf die Idee,
zwei Folgen A und B so zusammenzupacken,
dass die entsprechenden Geordneten Elemente in dieser Folge hinterher dann auch wieder alle entsprechend geordnet in der nächsten Folge drin sind.
Weil Duplikaten muss man halt gucken, wie der Algorithmus jeweils funktioniert,
aber wenn es sich um identische Einheiten handelt,
soll es ja auch egal sein, dem,
wo sie natürlich nicht identisch sind, muss man den Suchschlüssel heute das Ordnung skriptieren, entsprechend verändern.
Wenn ich also sage, dass hier Müller dreimal vorkommen kann,
weil die Vornamen sind mir egal,
dann ist es eben egal, dann kann es eben sein,
dass Xaver vor Anton steht in der Reihenfolge,
weil es halt nicht relevant war, wenn ich das mit einbeziehen will,
muss ich den Schlüssel darauf erweitern, nur um das nochmal am Rande kurz zu erzählen.
Jo, dann ein ganz einfaches Beispiel,
wo auch dann hier die entsprechende Doppelung mit der Vier entsprechend sehen,
wir kommen dahin und sortieren das und dann haben wir
die Vier zufälligerweise da oder hätten sie wahrscheinlich am Ende,
mittendrin ist eher unwahrscheinlich
Gut, die entsprechenden Mengen kommen da rein und wie man das einsortiert,
sollte relativ klar sein, wie er solche Zahlen reinsortiert hier,
gehe ich mal von aus. So, dann haben wir den Merchshot,
wir haben hier unten so einen schönen Baum,
also das heißt, wir haben hier einen schönen Baum,
so, und wir haben hier unten die entsprechenden Zahlen,
die wir irgendwie erstmal unsortiert haben, machen unser Palissortieren,
Merchshot und gehen da hin und schauen uns jetzt an,
was da so entsprechend drin passiert.
Also immer die zwei, die so ineinander liegen,
zufälligerweise haben wir auch acht, teile hier liegen,
haben wir so vier solche entsprechenden Blöcke, Was machen wir jetzt?
Wir sortieren? Wie sortieren wir diese beiden? Nee,
wir sortieren sie entsprechend da rein, sodass wir in den
jeweiligen Ebenen hier drüber die entsprechenden Sortierungen der Zahlen hinbekommen,
was man dann entsprechend hier jeweils wiederfindet.
So, das gleiche Spiel machen wir dann nochmal,
indem wir jetzt wieder zwei haben.
Und jetzt wird es natürlich schon ein bisschen spannender,
wenn wir hier zwei Zahlen haben, die wir gerne ordnen,
so müssen jetzt die Sachen so einsortieren.
Gehen wir mal davon aus, dass wir das jetzt so hinbekommen,
dass wir das da machen können und dann wird entsprechend hier wieder einsortiert.
Und jetzt nehmen wir halt über die ersten Elemente nehmen und
dann reinschieben
Gut, das ist jetzt sozusagen unser Teil,
dass hier oben die obere Liste letztendlich erreichen. So,
um das jetzt ein bisschen anzugucken und solche Sachen näher zu betrachten,
haben wir in ein Jahr geordnete Menge, die wir da haben,
haben so einen Rang und definieren das jetzt,
dass wir sagen, okay,
wir haben diese Elemente da drin und wir können jetzt irgendwie so einen Rang angeben für diese entsprechenden Dinge.
Das heißt, Anzahl der Limit XI mit XI,
kleiner als X, das ist mein Rang.
Wenn ich jetzt also irgendwelche habe, kann ich jetzt überlegen,
welchen Rang haben die jetzt hier sozusagen
Und der Rang von 13 ist jetzt die Frage, wo der ist.
Und naja, dafür müsste man sich erst mal sortieren oder sowas.
Und durch das Entsprechen angucken. So,
wenn wir jetzt die sortierte Liste jetzt hier entsprechend nehmen,
gucken wir uns die 13 an.
Naja, nullte Position, erste, zweite. Und entsprechend
packen wir sie hier rein und haben den entsprechenden Rang gleich zwei.
So, das Ganze kann man jetzt noch ein bisschen ausweiten,
dem man solche entsprechenden Mengen von Dingen nimmt
Die jetzt zuordnen, ist so ein rangfähiges ein Element angeben
und hat dann hinterher eine Liste von Hängen sozusagen da eingetragen,
wo für jede Zahl einzeln einsortiert wird.
Die Frage ist da nur, wenn ich jetzt die 13 einsortiert habe,
ändert sich dadurch der Rang für die restlichen und muss ich irgendwas korrigieren.
Das ist eine Geschichte, die hier nicht weiter beantwortet wird,
sondern man geht einfach davon aus,
dass man das nimmt,
was da entsprechend bleibt und nur weil ich hinterher eine minus 27 einsortiere,
ändert sich das nicht auf drei oder sowas ähnliches,
sondern wir gucken uns eine bestehende Liste an und dann nehmen
wir die Liste,
die dazu genau entsprechend passt
Jo, gut, damit haben wir jetzt so ein Handwerkszeug
sozusagen zur Verfügung und jetzt kommen wir jetzt zum Mischen und wenn ihn an,
das wäre das Ganze sich jungt haben.
Das heißt, wir mischen die also immer fleißig bunt,
aber es ist unterschiedliche Zahlen sind.
Und entsprechend wird bezüglich des Rangs das einsortiert,
sodass wir also die entsprechenden Elemente dort reinpacken können, um das dann entsprechend einzusortieren.
Und wir packen die beide zusammen, diese Mengen und sagen,
okay, wenn es an der dritten, vierten,
fünften, sechsten, achten Stelle und so weiter ist,
haben wir die entsprechende Ränge der jeweiligen Elemente auch da mit angegeben.
Das heißt, wir können dann damit arbeiten.
Wir können hier uns das auch so vorstellen,
dass wir die beiden erstmal separat angucken und dann hinterher die
Sachen zusammenpacken und können das jetzt hier machen und können das
mit mir entsuchen erledigen und das sortieren wir dann halt eben bei A ein.
Wird dann bitte angefangen, dann höpieren wir wieder nochmal und rechnen das entsprechend aus.
So und das Verfahren kann parallel auf alle Elemente von B anwenden,
das heißt, wir halten ein paar Lenkrhythmus mit UVNLOGN,
paralleler Zeit und Wovon N-Log in Operation,
weil es eben für die entsprechenden Zahlen immer machen müssen,
in halbe.
Gut, also um 1-1 zu sortieren,
brauchen wir Log. In Schritte und das machen wir für
die zweite Reihe und dann haben wir den Kram da drin.
Gut, das ist sozusagen die eine Größe und das
ist die zweite, die da drin ist.
Jetzt die Frage, ist das jetzt eigentlich optimal und
wie sieht es damit aus
Wann ist ein Algorithmus optimal? Sollte spätestens in zehn Tagen dann
sehr klar sein oder man fuckt noch vier Wochen drauf,
aber... Also wann war so ein Ding optimal? Wenn
die Operation Komplexitätsleite ist mit der Zeitkomplexität in sequenziellen Erwartungen.
Von Hause. Und wie setzt es beim sequenziellen Algorithmus aus?
Wie sortieren wir solche Listen? Welche Größenordnung hat das?
Wie würdet ihr zwei sortierte Listen sortieren?
Operationen dauert das.
Wie kommt das? Ja? Es kam hier nach der Minusverhältnis, die Grenze.
Genau, wie kommt das jetzt? Wie macht man das
vom Prinzip? Die Idee? Mit anderen. Naja,
genau, wenn es sequenziell ist, packt man den entsprechend einfach
direkt zusammen und verwebt das sozusagen, von vorne kommt.
Genau. So, jetzt ist das fürs Mission,
es wird jetzt nochmal ein bisschen spannender,
was wir jetzt machen ist,
wir gehen jetzt hin und fangen an,
unsere Listen mal in Blöcke aufzuteilen
Das ist ja so ein typisches Verfahren. Ich hoffe,
ihr habt euch die Olad-Sachen angeguckt, beziehungsweise das Skript, was ihr lesen deutet.
Dann habt ihr jetzt diese ganzen Algorithmen sozusagen zumindest mit den
ganzen Indizes und all diese Dinge ja hoffentlich schon mal so etwa gesehen.
Für eine Klausur würde man hingehen und dann zum Beispiel
die Algorithmenvorliegen fragen, wie sieht es denn damit aus?
Und wenn ich das jetzt hier ändere, wie sieht das dann damit aus? Also,
dass wir zum Teil auch Algorithmen nehmen,
die nicht genau dem entsprechen, was da vorliegt,
was wir im Skript haben und dass man sich dann Gedanken machen muss,
in welcher Form funktioniert jetzt dieser Algorithmus hier,
weil wir jetzt Andere Größe, andere Blöcke,
eine andere Art von Schleife verwenden, die eventuell sogar schlechter sind,
was uns ja nicht stört bei der Prüfung,
sondern ihr müsst erkennen, was dann jeweils zwar ein Laufzeitververfalten vorliegt.
Was wir bei uns jetzt nicht machen müsst in
der Prüfung im Hinblick auf diese paar den Algorithmen,
ist selber euch einen besseren Algorithmus dann zu überlegen an der Stelle.
Das lassen wir erstmal weg. Gut,
aber jetzt ist erstmal eine der Ideen ja,
dass man hingeht und A und B jetzt im Blöcke von fasten der Länge aufteilt.
Und jetzt ist immer die Frage, was sind denn da passende Längen?
Und wir sagen jetzt, wir haben eben A und Hattelinge Enden und B-Hittling M.
Und jetzt haben wir hier irgendwie diese Plakette, die wir aufteilen wollen.
Jetzt gucken wir uns an, wie viel das sein sollen.
Es sollen M durch Log Amblöcke sein und
so viele Blöcke möchten wir jetzt hier gerne haben.
Und so teilen wir auch diese beiden Bereiche auf.
Und das Ganze muss halt ganz zahlig sein.
Und das sind entsprechend die vielfertigen Zahlen,
die man dann da rauskriegt, wo man gucken muss,
okay, wenn es 18 oder 3, wie sieht es aus?
Naja, nehmen wir die zwei oder die vier hier
Ja. Dann funktioniert das schon entsprechend. So,
was machen wir jetzt? Wir gucken uns denen zu,
dass die entsprechenden AI dann sagen können, okay,
die sind kleiner als die oder bzw. die null sind kleiner als die WI,
dass wir das sozusagen entsprechend einrichten können.
Und was wir jetzt haben wollen, ist,
dass alle X aus diesem BI davon größer sind als die
von AI minus 1 aus diesen Elementen.
So, und für den Fall,
dass wir jetzt hier gleich zwei haben,
wir haben gleich irgendwelche vier Wählen an dieser Stelle
Dieses hier. Wir haben B mit der Linke 4,
hier haben wir so eine Folge und jetzt wollen wir das irgendwie da so aufteilen.
Wenn wir uns angucken und passen jetzt auf,
dass das hier sozusagen die Schreibweise für die entsprechenden Indizes dann ist,
wie wir es oben nochmal sehen,
müssen wir also dieses hier irgendwie da in Beziehung setzen und in Blöcke jetzt entsprechend aufteilen.
Und das sind unsere beiden Zahlen, Folgen, die wir da angucken wollen.
Wir haben das BE mit dem Lygorithmus von M.
Wir teilen das quasi jetzt in der Mitte durch und gucken,
wie das da ausschaut und jetzt müssen diese Elemente,
die jetzt hier sortiert drin sind,
natürlich irgendwie hier oben mit hinkommen.
Das heißt,
ich teile das entsprechend hier oben
Entsprechend durch, sodass die Elemente kleiner sind, als die hier drüben.
So, damit haben wir so eine entsprechende Aufteilung. Das kann jetzt also sehr unbalanciert,
wir balanciert sein, je nachdem,
wie die Zahlen dreien gerade aussehen, wenn die nur zahlen,
kleiner werden, als die anderen würden alle konsequent dahinter insortiert werden,
würde man halt entsprechend dann auch sehen dabei.
So, was wir jetzt also haben, ist,
dass wir solche A und Bs haben und diese,
in Beziehungssätzen zu denen hier unten, müssen jetzt gucken,
wo packen wir das denn jetzt hier unten entsprechend rein,
was wir so brauchen ist,
wir müssen das Ganze jetzt irgendwie palitionieren und irgendwie aufteilen,
das Ganze
So, und jetzt kann man diesen Algorithmus ja im Einzelnen genau durchgehen.
Ich werde es einmal kurz sozusagen einblenden und schrittweise einmal durchgehen,
was wir jetzt auch im Skript drin war.
Eingabe ist also, dass wir zwei Felder haben,
in aufsteigender Reihenfolge sortiert, da von dir das schon mal aus.
Und haben eben ganze Zahlen für Log-M und keinem da drin
und haben hier entsprechend unser Beispiel jetzt wieder aufgegriffen.
So, dann ist die Frage, was ist die Ausgabe?
Die Ausgabe sollen entsprechende Paare von Teilfolgen von A,
B sein, sodass wir das B,
I ist immer die Anzahl von, ist immer Log von M.
Das heißt, wenn man so zwei Dinge da drin für
unsere BI und die Anzahl der AISA-Welten gleich N sein.
Und jedes Element von AIOB ist größer als jedes Element von
AI minus 1aB minus 1 für alle,
die wir da entsprechend jetzt drin haben, für die Indexbereiche.
So, das ist das, was wir jetzt gerne raushaben möchten dabei.
Und dann gucken wir uns mal an, was wir da machen.
Wir packen hier die entsprechenden, hört erstmal rein und sagen,
da sind wir sozusagen vorweg für unsere Variablen und gehen jetzt entsprechend
Das Ganze durch. Und zwar lebenläufig gehen wir jetzt hin
und brechen in den Rang von diesen Dingen durch binäre Suche
und setzen das JI auf den Rang von diesem BI,
von Log M in den Bereich A.
Gucken wir uns das jetzt an, wo müssen wir jetzt
diese ASA entsprechend reinpacken. Und die zweite Schleife sorgt dann dafür,
dass wir die BIs wiederum haben, die wir vorher schon stehen haben.
Und die AIs packen wir entsprechend voll mit den AJs,
die jetzt bezüglich dieser Einsortierung entsprechend hinkommen.
Und das Eis leer, wenn die beiden halt sozusagen als gleich angesehen werden.
Wie gesagt, wenn ich jetzt sozusagen einfach keine Zahlen finde in einem bestimmten Bereich,
dann kann das auch entsprechend leer sein, dieser Block,
in dem ich das jetzt einsortiere.
Das heißt, es kann passieren, dass hier gar keine negativen Zahlen sind.
Hier habe ich nur negative Zahlen oder sowas,
packe die davor oder sind wir dahinter, je nachdem,
welcher Algorithmus jetzt gerade ergreift.
So, jetzt gucken wir uns noch ein bisschen genauer an. Wir haben ein Beispiel,
wenn wir also das jetzt hier sozusagen uns inmitte angucken,
müssen wir genau diese entsprechenden hier finden und haben diese BEI,
also B1 bis B4,
die wir hier entsprechend jetzt drin finden und wir vergleichen das und sorgen dafür,
dass die 4, 6, 7 mit dem 3,9 entsprechend einsortiert werden.
Und das wird ja also hier an dieser Stelle bezüglich der Ranggeschichten mit verorten.
So, dadurch, dass wir jetzt das I gleich 2 wählen,
haben wir also einfach nur zwei Teile dabei.
Und was wir jetzt haben, ist,
dass wir hier unten dieses IO2 dann sozusagen anbinden und haben
das entsprechend dann auch hier beim Logorithmus auch mit drin,
den wir dann hier oben mitfinden.
So, was haben wir jetzt davon? Wir singen jetzt
hier oben diese BIs, die sich hier unten auf diese,
die jetzt sozusagen beziehen und für die wie jetzt die Schleifendurchläufe durchführen.
Und haben dann entsprechend hier die entsprechenden Blöcke in diesem BI,
die wir uns dann angucken müssen.
So das Gleiche dann unten mit den Eis,
die wir dann sozusagen je nach Bedarf wählen,
in einem Betracht der Ergebnisse, die wir hier oben hatten.
So und durch die Pensionierung erreichen wir jetzt,
dass wir die Sachen auch entsprechend einsortieren können,
weil die Ränge innerhalb dieser Bereiche jetzt sozusagen haben.
Wir haben jetzt also genau das,
was hier kleiner ist, dass unser C0,
was sich eben genau aus diesem Bereich jetzt hier oben eben ergibt,
Und da drinnen sortieren wir das entsprechend genau ein,
aufgrund der entsprechenden Ergebnisse, die wir da drin haben.
Da sind zehn sortierte Folge, welche wir durch das Mischen
der sortierten Folgen A und B mit der Längen N&M erhält.
Also wir haben jetzt diese beiden Längen, die da entsprechend drinstecken.
Und dann teilt der Algorithmus eben A,
B und Paare von Teilfolgen auf, die eben genau diese Charakteris redet,
wie wir oben hier gerade besprochen haben, enthalten.
So, und das Spannende ist jetzt,
der Algorithmus benötigt der O von Login Zeit mit insgesamt O von N plus M Operationen.
Und jetzt die Frage, wie man da genau drauf kommt,
da gucken wir gleich nochmal kurz drauf
So, das Durchschneiden da oben sollte inzwischen klar sein und
dass sich das natürlich hier in dieser Folge wiederfindet, ist dann auch klar.
Obwohl ich entsprechend das Einsortieren hier oben eben in einem
größeren Bereich passiert als hier unten bei dem kleineren Teil,
weil man ist und das liegt daran,
dass die Grenze hier unten so gewählt worden ist an der Stelle.
Dadurch kommt diese Aufteilung jetzt zustande. So,
die entsprechenden Dinge hierzu kommen jetzt eben dann auf der nächsten Folie,
wo wir uns dann die Komposität nochmal angucken wollen
Wir sind jetzt hier wieder bei diesem Algorithmus und haben jetzt
die entsprechenden Blöcke. Und jetzt die Frage,
welche Zeitkomplexitäten haben wir denn jetzt eigentlich vorliegen?
Naja, und wenn wir jetzt hier oben mal gucken,
schauen wir, was da drin so passiert.
Insgesamt hier in diesem Bereich. Und dann ist die Frage,
was passiert hier? Wie lange dauert das so in etwa
? Schöne geformte Eins, aber fast das
Ja, ne? Wir haben UVN 1, warum?
Das sind zwei einfache Zuweisen. Sind einfache Zuweisen an der Stelle,
ja. Das ist, und lässt sich auch entsprechend machen.
Genau. So, dann kommen wir auf den nächsten Block.
Da wird es dann schon ein bisschen spannender.
Wie sieht das damit aus? Ich bin ihre Suche.
War irgendwas mit dem Luca Rhythmus, ne?
Jetzt die Frage, wie viel passiert das?
Und jetzt machen wir es ja ganz oft,
aber es wird eben in dem Pardu ausgeführt
Ich fehle mir auf den Mündern so die geformten Zahlen,
aber... Genau, ne? Lockend scheint so die,
ne, weil Logorithmus muss aus dem Logorithmusbuch haben, ne?
Genau. Ofondok N, weil wir darüber wieder zulaufen und
das hier läuft parallel ab.
Also von daher haben wir da genau die entsprechende Zeit Komplexität.
So, und jetzt hier unten wird es wieder einfach,
sag ich mal,
was macht man da nur
Da haben wir eben eine sehr ähnliche Aussage. Wir machen das
ein paar Duo, weisen das zu und liegen damit dann halt
auch wieder in Ufern 1 entsprechend da entsprechend mit drin.
Gut. Insgesamt haben wir also, was?
Naja, wir liegen wieder bei Ufern-Login an der Stelle.
So, was war die Zeitkomplexität? Wie sah es mit
den Operationen aus? Wie sind da die Vorschläge?
Ja, es ist genau so, genau so.
Genau so könnte da also
gut hinkommen
Ja. Beim nächsten passt das nicht mehr.
Da muss man schon ein bisschen genauer drauf gucken.
Ja, blind ist mein Verein. Wir haben diese Login,
das ist ja allein unsere Geschichte, die wir von da drüben haben.
Und jetzt die Frage, was passiert denn da drüben?
Und da hat das M durch Login,
weil das ja entsprechend sich jetzt hier drin widerspiegelt,
dass wir genau diese Anzahlen da drin haben.
So, das kriegen wir quasi von hier oben, also von Von da quasi her.
Und das können wir jetzt abschätzen, sozusagen. Weil wir jetzt,
wenn wir es entsprechend hier multiplizieren, das ist entsprechend da rausnehmen,
kann man eigentlich hingehen und sagen, okay,
das muss irgendwie mit Endfluss enden sozusagen hinkommen in der Größenordnung und kann das sozusagen nach oben hin abschätzen.
Das ist auf jeden Fall kleiner sein wird als sozusagen jeweils
die beiden Längen von diesen, von diesen Dingen.
So, und insgesamt kann man das jetzt angucken,
da wir so dieses mal Login durch Log M und so weiter,
das kleine Alt und so weiter,
kann man das eben hier sich entsprechend angucken.
So, und N&M sind ja größer gleich vier,
wobei das M wäre hier in dieser Feind bei unserem Rechnen natürlich nicht ganz hinkam,
aber das passt auf jeden Fall dann damit rein.
Hier vorne brauchen wir O von M,
weil wir die entsprechenden Anzahlen ja durchführen müssen und kommen ja
letztendlich auf das O von N plus N,
an der Stelle.
So, optimale Algorithmus fürs Mischen
Ist jetzt die große Kunst. Mit diesem Algorithmus haben wir
jetzt das Mischproblem der Größe N auf Unterprobleme kleiner Größe reduziert.
Also wir haben das passioniert. Gut. Dann,
wenn den Algorithmus zum Aufteilen an,
ist jetzt die spannende Frage und behandelt die Paare AI und B
getrennt und dann gilt eben die Anzahl von B ist da drin,
ist Log N und die werden entsprechend parallel bearbeitet.
So und falls das, falls die Anzahl der AIs,
die wir jetzt hier haben,
klein ist als das C-Log N,
mischen wir die also in entsprechend O von Log N
Zeit mit einem sequenzhelmischen Algorithmus
Ich kann das also entsprechend verbinden, wenn das nicht der Fall ist,
dann mit dem Algorithmus an und packen jetzt wieder die Zerlegung mit rein,
in die Blöcke mit O von Login und dann wird O
von Loglock Endzeit und den entsprechenden Operationen benötigt.
Gut, kann man jetzt sich im Detail angucken,
wie das in Algorithmus genau passiert.
Das machen wir jetzt nicht hier sozusagen. Ich meine,
wir haben ein paar Sachen jetzt dazu erzählt, aber gucken,
es ist einfach so nochmal dann an und das,
wo das alles genau herkommt,
also hier zum Beispiel Produktionalität zur Länge des Teilblogs
und so weiter
So, bei diesem optimalen Algorithmus für das Mission,
da wird also hier 1024 hätten, kann man das entsprechend verschieden aufteilen,
je nachdem, wie es sich gerade ergibt,
aber da kann man auch so asymmetrische Blöcke drinnen haben.
Und jetzt, wenn wir das Ganze zerlegen und muss dann
halt über Zeit und Operationen gehen und gucken,
was das jeweils kostet und schaut sich an,
wie diese W2 und A2 Sachen dann hier einsortiert werden.
Das heißt, ich zerlege das wieder in die entsprechenden Blöcke
und packe das andere da entsprechend mit rein und habe dann
eben parallel diese O von LogLog-In-Geschichten da wieder drin für
diese Bereiche
hier unten
So, und die Operationen sind dann die Anzahl von den As 2,
die wir da drin haben, die wir dann durchführen müssen,
weil wir für diese Elemente das ja entsprechend machen müssen.
So, das ist wieder entsprechend proportional zur Länge des Teilblocks.
Also geht es immer darum, wie lang ist dieser Block,
wie viel Zeit brauchen wir denn wirklich, länger der Block,
ist um eine Zeit, brauchen wir natürlich auch.
Und das oben ist eben lockproportional zur Länge des Teilblocks von den oberen Teilen da vorne,
je nachdem, wie lange wir den wählen,
über den halt größer wählen, kommen andere Sachen raus,
hatten wir beim Algorithmus ja schon gesehen.
So, jetzt können wir daraus noch einen Satz ableiten und
das mischen zwei Erfolgen A und B, der Ling N,
ist von einem Ob die mal einen Parallelalgorithmus in O-Phan Login Zeit mit O-Phan den Operationen durchführbar.
Das war also genau das, was wir auch uns erhofft haben,
dass wir das hinkriegen können, dass wir auch in meinem Parallelalgorithmus,
das sind die rhythmischer Zeit hinbekommen und mit O von N-Operationen.
So, jetzt stellt sich die Frage, geht es halt irgendwie noch schneller?
Und ich hatte ganz am Anfang schon ein bisschen was dazu erzählt.
Irgendwie kann man auf die Idee kommen,
dass das Ganze noch schneller gehen könnte.
Und da ist jetzt die Frage,
was man da jetzt erstmal machen kann an der Stelle
So, und da kommt man also da oben nochmal auf
die Idee kommen, das jetzt hier zu verbessern.
Und ist die Frage, wo könnten wir jetzt dieses,
wovon Login, bei dem Algorithmus, den wir vorher hatten, noch verbessern?
Also wo ist noch Potenzial für die entsprechende Beschleunigung?
Wenn wir jetzt wieder zurückgehen zum Algorithmus, wird das wahrscheinlich hier sein,
weil da dieses mit Ofen 1 da drin stecken,
muss es also irgendwie hier in dieser Region sein.
Wir müssen also hier irgendwas entsprechend verbessern. Das heißt,
genau da müssen wir jetzt hingehen und da müssen wir sehen,
dass wir jetzt durch die Anzahl der Prozessoren irgendetwas machen.
Wir können also sehen, dass wir durch die Prozessorenmenge
sozusagen jetzt irgendwie etwas bearbeiten und dass dadurch noch verkleinern.
Dazu müssen wir jetzt auf die Idee kommen,
irgendwie parallel zu suchen mit diesen entsprechenden Prozessoren.
Und wir müssen jetzt also gucken, wie wir das besser hinbekommen.
Und da möchten wir eben genau zu dieser O von Locklock-In-Zeit
entsprechend hinkommen an den Stellen.
So, und bezüglich der Operation wollen wir denn O von N
, Locklock-In ankommen. Jetzt geht es also Richtung Parallelis Suchen
an dieser Stelle erstmal
Und wir haben uns wieder unsere entsprechend geordneten Folgen und seinem Y gleich S,
was wir also jetzt sozusagen uns angucken wollen.
Und wir möchten also jetzt hier irgendwie so ein,
auf diesem Suchtproblem haben wir dann halt einen entsprechenden Index,
von wegen Ranking und so weiter.
Beim venäheren Suchen haben wir eine Zeitkomplexität,
die wir ja schon kennen, das ist jetzt klar.
Und jetzt haben wir aber Parallelen suchen,
ÖP-Prozessoren wollen wir eben entsprechend in diese Region hier kommen.
So, und der Algorithmus optimal,
wenn das P entsprechend konstant gehalten wird
Gut, so, jetzt haben wir wieder diesen großen Block hier,
das war das, was wir gesagt hatten,
dass sie auf jeden Fall vor das Skript angeguckt haben sollt,
oder das jetzt im Detail, wenn ich jetzt alles versuche,
die ganzen Buchstäbchen hier alle genau durchzuixen,
dann wird das noch ermüdender,
als diese Veranstaltung heute ohnehin schon ist,
zu sagen, ja,
weil das relativ trockener Stoff ist an dieser Stelle hier und man sich relativ klar mit diesen einzelnen Schrittchen jetzt sozusagen auseinandersetzen muss,
es kommt noch ein Schrittchen und noch einer und noch einer und noch einer und wird immer besser und ich erzähle jetzt mal,
ihr müsst also auf einmal rausnehmen,
an welchen Stellen treten Verbesserungen auf,
mit welchen Verfahren machen wir das jeweils.
Und wir haben das ja so mit Positionierung gearbeitet,
wir haben mit Bäumen gearbeitet, um da überhaupt hinzukommen mit dem entsprechenden Benärensuchen.
Wir positionieren Dinge, wir reorganisieren Sachen,
wir packen das also in andere Blöcke rein, wir gucken uns an,
wie wir das einsortieren können und benutzen da drin jeweils wechselt die Algorithmen,
das da reinzutun.
Und wenn wir ein Algorithmus haben, gucken wir uns an,
welche Komplexität hat der jeweils und dann versuchen wir Schritte,
wie wir das jeweils an diesen Bereichen noch verbessern können.
An dieser Stelle hier wollen wir jetzt mehr Prozessoren dazunehmen und jetzt ist das,
was ich ganz am Anfang erzählt habe, ja,
ihr habt eine Struktur, Ihr wisst, was ihr machen wollt.
Ihr wollt irgendwie diese Suchen-Sache irgendwie programmieren für irgendetwas.
Und jetzt die Frage, lohnt sich die Programmstruktur zu verschlimmern,
um dadurch investere Laufzeitkomplexität hinzubekommen?
Und hier habt ihr ein schönes Beispiel dafür,
wie jetzt der Code, ein kleines bisschen anstrengender aussieht,
als das, was wir vorher hatten.
Das, warum man das macht, ist,
dass man hinterher eben schneller ist. So,
und dieser Gewinn ist schon enorm groß und es dauert durchaus
zwei Minuten, bis man darauf selbst kommt,
wenn man
es selber machen müsste
Also selbst nachdem ihr euch erklärt habt,
was die grundsätzlichen Ideen sind und ich blende das wieder aus
und sage bitte, Klausur, bitte schreibt mal auf,
wie ihr das jetzt besser machen würdet.
Ihr habt ja so die Ideen von mir alle erzählt bekommen.
Würde das sozusagen euch mit dem Zeitbudget, was ihr in
der Klausur habt, ein bisschen überfordern an der Stelle.
So, wenn ihr jetzt wisst, dass das drankommt,
dann habt ihr eine Chance, das nachzuvollziehen,
aber das ist, als wäre oder weniger einen runterbieten.
Also macht euch prinzipiell klar, was ihr da macht und
macht euch prinzipiell mit den Verfahren vertraut.
Diese konkrete Ausprägung von diesem Algorithmus jetzt genau im Detail jetzt runter zu exerzieren,
ist jetzt nicht das, was man unbedingt sozusagen so machen muss.
Letztendlich ist es aber so, dass diese Algorithmen ja diesereigt
werden müssen und die sollen genau von euch sozusagen geschrieben werden, diese Algorithmen.
Das heißt, ihr sollt hinterher hingehen und wenn ihr irgendwann
bei Firma X sitzt und ihr sollt da etwas lösen,
dann müsst ihr diese Algorithmen bauen und nicht nur für einfache Suchen,
sondern für viele andere Dinge.
Und dann müsst ihr euch an die Verfahren von dem Algorithmen-Design sozusagen erinnern.
Was kann ich dann jeweiligen Stellen machen, um Sachen besser hinzubekommen?
So, das ist meine Verkaufsshow sozusagen für euch.
Die müsst ihr mitnehmen oder auch nicht mitnehmen,
wie auch immer.
Das ist sozusagen
die Intention dahinter
Nicht konkreten Verfahren. Naja, ihr werdet enorm viele Libraries finden,
die euch so und so schon hervorragende Algorithmen liefern. Mir versucht,
das dann besser zu machen, dann dauert es immer eine Weile,
bis man das wirklich besser hinbekommt an den Stellen.
Und selbst wenn wir ein Buch rausholen, das abschreibt,
Papier ist geduldig, kann das so Fehler enthalten, ihr vertippt euch dabei.
Und auch das Umsetzen ist nicht immer ganz, ganz trivial. Das heißt,
wenn ihr das diesen Code hier einfach mal kurz umsetzen müsst,
vertut ihr euch, was weiß ich,
bei der Bottomfunktion hier irgendwie, ja,
oder habt irgendwelche Berechnungsgeschichten da nicht drin oder packt fast irgendwo nicht auf oder sowas.
Und diese Fehler treten dann nur in Spezialfällen in der Ecke irgendwo auf,
wo es eben genau darum geht,
dass ein Limit eins zu früh oder ein zu spät einsortiert
wird und mit einmal hat ihr eine nicht mehr sortierte Liste,
obwohl ihr nicht denkt,
sie versortiert
Was dann auch zu entsprechenden Problemen führt. So, wie immer,
bei so Algorithmus, Eingabeausgabe und was tun wir da drin?
Wir haben also die Eingabe mit den entsprechenden Feldern,
ein Element Y, was eben herausgegriffenes Element ist.
Wir haben die Anzahl der Prozessoren,
wir sagen also vier Stück oder wenn ihr hier fertig seid,
werden es wahrscheinlich 32 Prozessoren im Rechner sein,
die euch locker zur Verfügung stehen und mit denen dann hantieren könnt und dann arbeiten könnt.
Und die Prozessorennummern sind dann von 1 bis 4 entsprechend durchnummeriert,
hier mal auch nicht von 0
bis Pminus
So, die Ausgabe ist ein Index, i, mit den XI,
die alle kleiner sind als XY und den XI plus 1,
die entsprechend alle größer sein sollen.
Was wollen wir also? Wir wollen also irgendeinen Punkt in dieser Folge finden,
der eben das Element oder eben die entsprechenden Größergeschichten hier wieder findet.
Also entweder ich treffe das Element, dann ist es
genau das, was wir mit dem Ding gleichzusetzen ist.
Es steht dann trotzdem rechts davon, uns auf jeden Fall
links von allen Zahlen, die größer sind.
Wenn es das Größte ist, ist es da und wenn
es dort ist, ist es auf der anderen Seite.
Jetzt kommt auf die Idee und sagt, okay,
gut, ich will ja irgendwie jetzt,
muss ich den Rand irgendwie ein bisschen ausrechnen,
habe ich also irgendwie so minus unendlich und plus unendlich da eingesetzt.
Das ist dann etwas, was wir gleich noch sehen werden,
aber das ist halt so ein Frechenkrams, die man am Rand damit reinpackt.
Wir ins Programm der Mindesten endlich eingeht,
ist dann eure nächste Aufgabe zum Umsetzen des Algorithmus.
Alleine sowas dann mit zu erledigen. So,
gucken wir uns also hier oben erst mal diesen Bereich an.
Wir setzen also erst mal alle möglichen Werte ein und sagen 10
-0 ist 0 und P plus 1 ist da.
Also wir haben jetzt irgendwelche entsprechenden Cs,
die wir gleich noch sehen, wo wir die einsetzen. So,
wir haben also hier unsere entsprechende unser Feld mit den X-0 bis X-N plus 1. Wieso habe ich jetzt,
wenn ich da End-Dinge habe,
wieso habe ich jetzt hier Null und Endfluss 1,
wenn ich da doch nur X-1 bis X N habe.
Ja. Genau. Wir haben hier vorne nämlich genau das
X0 und das XN plus 1 eingeführt und die sind mit dabei,
also müssen wir die berücksichtigen und muss man ein bisschen aufpassen dabei.
Jo, sehr schön. Gut, das sind die beiden
hier oben, exakt. So, dann haben wir unsere Bereiche,
die wir jetzt hier einteilen, nämlich unser C0 und C4 gleich entsprechend eins.
Jetzt gucken wir uns die Schleife an,
die wir hier haben, sagen wir das ist,
müssen wir jetzt, müssen wir gucken,
wenn jetzt entsprechend das JPL 1 ist,
dann setzen wir das folgendermaßen
Dann setzen wir auf jeden Fall die QI, QJ.
Und wenn es Y gleich dem XQJ ist, dann hüpfen wir sozusagen raus.
Ansonsten müssen wir hier noch was tun. Wir müssen jetzt
nämlich das Ganze setzen und gucken uns jetzt an,
wo wir diese C-Aufteilung jetzt machen,
weil wir das Ganze immer so in so Blöcken haben.
Das heißt, wir haben einen links- und rechts-Block,
damit fangen wir an. Und jetzt suchen wir uns als nächstes
die entsprechenden Grenzen aus, indem wir jetzt wieder reinspringen.
Und gucken uns an, was darin passiert. Und dann
müssen wir auch gucken, ob es größer oder kleiner ist.
Und das setzen wir entsprechend, dass wir also unser Element
entweder links oder rechts von diesem CI jeweils setzen können an den Stellen.
Und wir schauen, was bei den Grenzbereichen. So,
und was wir jetzt hierbei machen können, ist,
wir haben jetzt also hier unsere entsprechenden drei Prozessoren und vier Bereiche.
Na, wie viele Bereiche haben wir bei Binären suchen?
Wie viele Prozessoren haben wir da? Zwei und einen Prozessor,
genau, und jetzt haben wir hier drei und haben entsprechend vier Bereiche,
weil wir uns auf diese Geschichten hier halt entsprechend konzentrieren und da natürlich genau gucken,
wie sieht es da eigentlich jetzt aus?
So, dann müssen wir uns jetzt orientieren und müssen da
raufschauen und wir haben jetzt hier unser Y,
das jetzt da meinetwegen liegen soll
Jetzt die Frage, was machen wir jetzt im Algorithmus?
Jetzt müssen wir natürlich gucken, wo ist denn das eigentlich?
Und jetzt müssen wir dem Ganzen irgendwie hier entsprechend null zu weisen und
den hier alle entsprechend eins. Das sind genau die hier,
wo wir die eins zu weisen und wo waren die alle entsprechend erstmal auf sozusagen null gesetzt. So,
das heißt, jetzt wissen wir also,
dazwischen muss das irgendwie sein, entsprechend dessen gucken wir uns jetzt an,
wie das ausschaut und gucken an,
wo wir da jetzt in dem Bereich drin sind und verfeinern jetzt diesen Bereich und sagen,
okay, wir nehmen wieder unsere Prozessoren, unsere drei,
ordnen die zu,
haben unsere neuen entsprechenden entsprechenden Kusia eingeführt und gucken jetzt erneut in diesem entsprechenden Bereich.
Und meinetwegen kommt es jetzt in irgendeinem anderen Bereich,
hier jetzt irgendwo rein oder sowas oder eben entsprechend einfach dazwischen und sagen,
okay, dann muss man da wieder weiterschauen.
Und wir sind jetzt bei den PRAMs,
wir können also diese entsprechenden Sachen alles schreiben,
wir können danebenläufig feststellen, sind er größer oder nicht,
dann schreibt das Ergebnis rein,
dann kommt der Vergleich und sagt,
bin ich größer oder kleiner,
wenn ich größer bin,
dann bin ich auf der rechten Seite und bei dem anderen
ist das zu verlinken und dann können wir auch genau sehen,
an welcher Stelle
das genau wechselt
Und genau diesen Bereich nehmen wir dann und zerlegen ihn wieder in die Teilblöcke,
die wir jetzt aber quasi immer kleiner machen.
Also dass wir es jetzt hier so aufweiten, ist natürlich,
also wir sind da nur noch in dem Zahlenbereich drin und gucken jetzt genauer nur rein,
mehr nicht und zerlegen das Ganze dann entsprechend weiter und suchen,
machen das rekursiv und gucken da entsprechend rein, stellen hier wieder sowas fest,
dass wir sowas haben und sagen dann irgendwann, dass wir fertig sind.
So, und wenn wir das jetzt hier erreicht haben,
dann haben wir also die entsprechenden Dinge und können genau sagen,
wo das Ding liegt und liefern den entsprechenden Wert zurück und können sagen,
jo,
da ist es dann entsprechend
So, jetzt können wir gucken. Das Parallele suchen mit
den entsprechenden Prozessoren. Wir haben also diese Prozession P1,
der ist zuständig für die Inzivilisierung und irgendwelche Randgeschichten.
Das war dieses Unendlich-Zeugs und so. Das wird das da weghaben können.
Das Aufteilen von X in P1 plus 1 Blöcke von der Vergleicherlänge.
Das wird auch passieren. Und jede Palide-Runde findet dann eben
dieses XI gleich Y oder wir finden eben einen Y enthaltenen Block.
Also entweder ist das da drin oder wir haben einen enthaltenen Block.
Also wir finden das Element oder diesen Block
und wissen das dann
So, und wenn wir jetzt so ein Beispiel uns angucken,
wir wollen ihn gleich 15 haben,
können wir so durchlaufen, wo es wo reinkommt.
Das ist schön. Wir nehmen unsere 19, die wir
genau hierzwischen jetzt weg haben und wollen nur zwei Prozessoren nehmen.
Das heißt, wir haben eine große Menge von Möglichkeiten,
die wir uns angucken jetzt hier und fangen erstmal mit dem
0 und 1 hier drüben an und haben da drüben die
16 und da die 0. Und jetzt schauen wir mal,
was da passiert.
So, und gucken uns das an und zerlegen das
und haben in der ersten Iteration dann,
dass man sozusagen in diesem Bereich hier sozusagen verbleibt
Bei zwei Prozessoren haben wir also jetzt entsprechend hier und hier den Schnitt gemacht,
wissen, dass wir hier drin sind, jetzt gehen wir hier wieder rein,
haben die nächste Iteration und stellen fest, dass wir hier vorne drin sind,
machen das Ganze noch einmal, bleiben da drin,
stellen fest, dass es genau nicht trifft,
sozusagen an der Stelle und wissen jetzt, okay,
das muss dazwischen irgendwie sein,
legt der linke und der rechte und die sind jetzt genau einen auseinander,
damit terminieren wir auch, das war das,
was den Algorithmus dann immer in einem der IF-Statement sozusagen dann mit drin steckte und wir können sozusagen aufhören in Sachen,
okay,
an der Stelle können wir das so zurückliefern hier
Und sagen, jo, der Rang ist neun,
weil er eben sozusagen an die neun Stelle nach dem neunten sozusagen damit entsprechend reinkommt.
Genau, so und wie man sieht,
ist das jetzt sozusagen ja dann schon sehr schnell.
Und je mehr Prozessoren wir haben,
desto mehr Blöcke können wir parallel angucken und desto schneller werden die auch verteilt,
weil jedes Mal der Block wieder in die entsprechenden N-Blöcke eingeteilt wird und entsprechend schnell wieder das zerlegt.
Ja, das ist also schon eine ganz nette Geschichte.
Und das entspricht jetzt hier genau diesen Sachen,
die ich vorhin schon sagte,
was am Ende da halt drinsteht.
So, Komplexität
Haben wir wieder einen entsprechenden Satz zur Erfolge X1 bis XN und
diesem entsprechenden Y brechende Algorithmus ein Index i,
der eben genau dafür sorgt,
dass wir das Y zwischen diese XI und XI plus 1
sozusagen einsortiert in der Zeitkomplexität von O von Lock N plus 1 durch Lock von P plus 1.
Wobei eben das P-Kleiner als das N die Anzahl der Prozessoren ist.
Also wenn wir es zufällig gleich haben,
dann ist natürlich relativ schnell geklärt, wo das Ganze ist.
Jeder vergleicht, jeder guckt Antwort durch. Das ist dann
relativ schnell. Aber wir gehen ja davon aus,
dass wir sozusagen viele solche Daten da eigentlich vorliegen haben.
Und bei dem Abbruch der Beischleife gilt eben entsprechend,
dass es genau da liegen muss für dieses entsprechende Intervall,
dass die da drin einsortiert sind.
Jetzt gehen wir sozusagen das Ganze wieder rückwärts durch.
Wenn wir auf einmal rückwärts gucken bei den Geschichten,
dass man quasi immer weiter hochmarschiert und wir kommen letztendlich bei
diesem Ausgangsintervall entsprechend wieder an, wo wir da reingucken.
Das also für die Anzahl der Schleifendurchläufe, die wir
da drin vornehmen können. Können wir also sagen,
dass wir sind Abhängigkeit von Anteil der Prozessoren hier bestimmen können.
Ansonsten ist es eben aufgrund der jeweiligen Potenz immer wieder so entsprechend drin.
So, kurz zusammengefasst. Mission von Folgen A und B,
der Länge N, haben wir so eine Tabelle,
die auch im Skript gesehen habt.
Und das steckt da jetzt alles drin. Wir haben unsere
entsprechende Zeit und Working oder Komplexität sozusagen haben als erstes Ergebnis.
Das hier als entsprechend optimal festgestellt, haben das mit entsprechend schnellen Suchen da drin.
Wir sind ein schneller, aber das hier wird ein bisschen unangenehmer.
Und wir kommen jetzt wieder auf die Optimalität, indem wir das jetzt wieder hinkriegen.
Und das ist das, was wir jetzt sozusagen dann auch angucken wollen.
Das heißt, wir wollen jetzt also hingehen,
dass wir das, was wir als Ergebnis haben,
gerade eben, möchten wir jetzt nochmal entsprechend verbessern.
Weil das hier oben, was jetzt ja mehr Arbeitsschritte sozusagen erfordert,
weil wir jetzt mehr tun müssen. Wie in IT,
jeder Schritt kostet eine jede Berechnung, kostet etwas.
Jede Google-Suchanfrage kostet so und so viel Strom und so weiter und so fort.
Also genau solche Aspekte kommen jetzt dann mit einer rein.
Und wenn man die Milliarden von Anfragen oder ab Operationen halt sieht,
dann wird es irgendwann spannend, sowas tatsächlich auszurechnen.
Wie viele Schritte habe ich denn und wie optimiert man das?
Und da kommt dann auch das Geld dann letztendlich wieder rein letztendlich.
So, und das wollen wir jetzt gleich nochmal genau angucken,
das binäre Suchen war, war das eine,
das andere, was Parallele suchen.
Und jetzt geht es halt durch das schnellere Mischen,
müssen wir halt noch ein bisschen besser hinkommen und müssen noch effizienter werden an der Stelle.
Und das heißt, wir jetzt also paralleles Mischen haben,
dass wir bei der Zeit noch ein bisschen runterkommen und da
drin werden.
Und das sind U von Locklock-Innen
Statement hier ist, das ist erstaunlich, da schon die
Maximumbestimmung Login-Parallel-Schritte erfordert. Das ist schon ganz interessant. So,
der Algorithmus berechnet diesen Rang von BMFSA,
in der Zeit Log Log N mit den entsprechenden Operationen,
die wir da drin haben.
So, was machen wir jetzt? Wir haben entsprechend hier
oben wieder unsere Aufteilung. Was ist jetzt hier neu?
Wie verzeihen wir jetzt unsere Blöcke? Was seht ihr dabei
Naja, hier oben steht irgendwie so ein Wurzelding da drin. Das heißt,
wir gucken, es wird einmal in einer anderen Art von Zerlegung
da drauf und per Magic ergibt sich, dass das Gutes ist.
Warum man da nicht die Kubikwurzeln nimmt oder irgendwas anderes oder
die Wurzelabhängigkeit von den Anzahl der Prozessoren oder so etwas,
das wird jetzt gar nicht mehr weiter diskutiert.
Das sind Dinge, wo ich eben sage,
das ist etwas, wo man irgendwann drauf kommen muss,
wie man das Ganze gestalten kann.
Das sind die Varianten, die ihr so durchprobieren könnt und
hier seht ihr es sozusagen, dass wir es hier angucken können.
Und wir suchen jetzt unsere JE,
die wir drin haben mit dem Rang von diesem Bereich hier
So, und der Algorithmus ordneisertierte Folge in eine resortierte Folge ein.
Wir haben also zwei Felder mit aufsteigender Reihenfolge und das Heilvier.
Wenn M ein kleines Satz vieren Orten Elemente von B durch
Anwendungsalgorithmus 10,2 mit P gleich N und dann ist man fertig.
Also das heißt, in dem Moment,
wo wir jetzt auf diese Sachen kommen,
dass das M sehr klein wird, sagen wir,
dann nehmen wir das andere, dann ist das durch.
Und ansonsten ordnete Elemente entsprechend in A mit Hilfesalgorithmen von 10,2
wieder ein. Und dabei haben wir als Anzahl der Prozessoren
Wurzeln Wurzeln sozusagen da drin.
Und der Rang wird entsprechend hier gewählt als Wurzel von M
auf diesem BI
So, und was dann letztendlich dann hier passiert,
dann setzt man diesen Rang und berechnet das Ganze rekursiv letztendlich hier hinten wieder weiter.
Und mir ging es hiervon aus,
dass wenn wir das K nehmen, haben wir den entsprechenden Index,
der kein Vielfaches von diesem, von der Wurzel sein soll.
Warum? Muss man wirklich genauer reinschauen. Und sieht man dann hier.
Und dann haben wir das I als entsprechendes K durch Wurzel-M.
Und dann wird der Rang so entsprechend bestimmt. So,
auf die Details dazu, wie gesagt,
kann man jetzt einmal kurz gucken, oben haben wir diese entsprechenden M,
die finden sich entsprechend bei dem Einsortiellen da drin wieder.
Und das schiebt man dann hier in diese entsprechenden Arth,
genau jetzt mit rein. Und das macht man mit Hilfe
der entsprechenden Algorithmen, die wir hier drin sind.
Und hier haben wir jetzt diese Teile,
die sich aus diesem da oben letztendlich ergeben.
Und für die Pallitionierung. Und das finden wir dann
hier in dem Teil zum Beispiel wieder,
indem wir diesen Block hier sozusagen da drin wiederführen und sagen,
da geht es entsprechend rein und sortieren das in den Bereich
hier drüben rein
So, die entsprechenden Beispiele jetzt dafür, ist so,
dass wir, wenn wir das jetzt hier nehmen,
haben wir diese Zweiteilung und sortieren das jetzt hier jeweils mit
ein und stellen fest, wie das jetzt entsprechend geht.
Da wird er entsprechend Rang genommen und angeschaut.
Und das sind genau diese, die jetzt zum Folien davor,
mit entsprechenden Farben einsortiert, sich genau auf diese Dinge beziehen.
Dafür muss man jetzt Algorithmus halt wieder ein bisschen im Kopf haben leider.
So, und diese Einsortierung hier ist in der Naturalit,
muss man natürlich gut aufpassen,
wie man das jetzt entsprechend hinbekommt und musst dann sehen,
dass das jetzt hier mehrfach reinrutscht.
Der Algorithmus berechnet diesen Rang in der Zeit von O,
äh, von Lockdog N mit diesem entsprechenden Operationen.
Und da habe ich jetzt den Beweis nicht mehr mit dabei. Das ist das,
was wir da jetzt nicht mehr mit aufgenommen haben,
weil das findet entsprechend im Skript, dass das,
was ihr euch da dann genauer angucken könnt und das wir dann nochmal nachvollziehen könnt,
wie das schrittweise jetzt geht, ohne dass das da drin ist.
Das andere ist, dass ihr im Grunde auf die Literatur schauen müsst,
sozusagen Begleiterklärungen zu bekommen, weil das, wie gesagt,
ja sehr plötzlich in dieses ganze Gebiet der parallelen Algorithmen reingesprungen ist.
Dazu findet ihr in dem Buch halt durchaus einiges an Erklärungen
und könnt da dann nochmal nachgucken.
Da geht es dann auch ein bisschen ausführlicher und umfangreicher rein.
Es gibt noch eine andere Bücher, das ist jetzt eins von denen,
die ihr da entsprechend finden könnt.
So, und da drin findet man auch,
dementsprechend gibt es die Korolare und entsprechenden Sätze wieder,
die dann eben da auch entsprechend gut bewiesen sind
Und wir kriegen so zwei Sortierte Folgen der Länge enden können,
also in Uf von Lockdown and Zeit mit den N von Lockdown Operationen gemischt werden.
Und dann haben wir den entsprechenden Satz,
dass das eben genau so ersetzt wird. Das war das,
was wir jetzt ja eben in der Zusammenfassung gesehen hatten,
worauf wir also hinsteuern wollten an dieser Stelle hier,
dass wir diese Dinge dahin bekommen.
So, und der Beweis ist nicht mehr mehr ein Skript,
sondern den findet ihr dann wirklich nur noch da und könnt
dort entsprechend nachschauen, wie das geht.
Wie gesagt, das ist eher so ein Anreiz zu gucken,
wie weit geht das eigentlich? Und wenn ihr jetzt zurück,
euch zurücksetzt und guckt, was ihr jetzt sonst so im Studium an Ja,
war Algorithmen bisher programmiert habt, dann ist das eben halt noch ein Unterschied.
Und da muss man halt systematisch dann arbeiten.
Und da ist die Hauptarbeitszeit nicht die Umsetzung in der Programmiersprache,
sondern die Hauptumsetzung gestellt darin, diesen Algorithmus zu designen und hinzubekommen.
Deswegen ist Algorithmendesign eben ein separates Topic, als sozusagen offline gemacht wird,
nachdem ja SE1 und 2 und 3 sozusagen bearbeitet habt.
Gut, jetzt gibt es noch ein letztes Schmankerl an
dieser Stelle jetzt hier,
nämlich das Parallele Merch dort
Das, ja, noch, es gibt immer noch einen obendrauf.
Da war ich ja gerade eben schon bei Satz 10 3
-2, war doch Schluss, oder?
Nein, es ist noch nicht ganz Schluss an der Stelle.
Jetzt kommt noch wieder das Bäumchen im Spiel, Bäumchen wechsel dich.
Wir haben jetzt hier irgendwie diese Möglichkeit,
das haben wir von gesehen, wie wir es parallel sortieren,
dort hinbekommen und gucken uns jetzt diesen entsprechenden Baum nochmal an und sehen die entsprechenden Höhen,
die wir da einblenden können und die entsprechenden Aufteilungen und gucken uns an,
was passiert da drin eigentlich und wie kann ich das jetzt parallelisieren?
Das ist jetzt auch nochmal eine Frage, was kann ich da
eigentlich gleichzeitig machen und wie geht das am besten und Was passiert da? Naja,
und ich vergleiche diese beiden natürlich, muss irgendwie hinkommen,
dass ich mit den Prozessoren da jetzt raufgehe und sage,
okay, die beiden, und mit der anderen mache ich die,
das heißt, ich muss die zuordnen mit den Prozessoren auf die Daten jetzt irgendwie hinbekommen.
Und ich komme jetzt sozusagen sukzessive hier in,
das sind da am Anfang, erster, zweiter,
dritter Schritt, und dann sind wir sozusagen da oben.
Und das sozusagen in Lockfund in Schritten aufgrund der Höhe von
dem entsprechenden Baum, was hier jetzt eben genau wiederzufinden ist.
So, und was wir da dann entsprechend drin haben,
ist jetzt diese entsprechende Höhe.
Jetzt kommt es auf den Algorithmus drauf an, was haben wir da?
Wir haben die entsprechende Eingabe, wir haben die Ausgabe,
die wir haben wollen, nämlich,
dass wir so notierte Liste rauskriegen
Und wir machen das mit diesem nebenläufigen Zuweisen,
dass wir erstmal sagen, wo liegt das alles?
Mit dem Null. Und hinterher wollen wir hin zu einem L2-1 kommen,
was dann entsprechend dieses Mischen von diesen Teilsachen nachher ist,
weil wir davon ausgehen,
dass wir eigentlich nur diese Teile nehmen und mischen und sozusagen jetzt dafür aufpassen,
dass die in der richtigen Reihenfolge sind.
Wir sortieren die jetzt quasi. Und dadurch,
dass wir dann sortierte Listen da haben,
schieben das sozusagen jetzt einmal durch den Baum durch.
Und das machen wir für die Höhe von dem Baum,
nämlich von 1 bis Lukryphmus N
sozusagen an der Stelle
Und was jetzt hier reinkommt, ist dieses zwei N durch zwei Hochhaar.
Und das ist jetzt die Frage, warum das eben das
zwei Hochhaar eigentlich ist. Da kommen wir gleich noch drauf
. Wir haben also hier erstmal also für die Wurzeln,
wer mit der Höhe J die entsprechenden Teile und wir haben das Haar auf diesem entsprechenden Legalithmus von N.
So, Unabhängigkeit von der Länge. So,
und bei den Mischen sollen wir eben dafür,
dass diese Höhe 1 und Höhe 2 J und dieses Teil
hier zu sortierten Liste LHJ zusammengeführt werden,
also diese beiden mit links und rechts werden jeweils immer genommen.
Und was ist passiert? Das solltet ihr auch aus den Satirsachen kennen von den Algorithmen,
dass man auf diesen Datenbeständen quasi mit dem Index arbeitet und dass man weiß,
was man jetzt wie zusammenfasst da drin.
Das ist immer so eine Magic-Geschichte, wo man mit einmal
über so einem Erry arbeitet und dann den Index so wird,
dass das Erry, das da drinsteckt und dann immer geschickt,
die Sachen richtig vergleicht.
Da steckt also auch bei den normalen Algorithmen schon drin,
dass man das, dieses Phänomen der geschickten Wahl von Indizes sozusagen benutzt.
Das passiert jetzt hier auch, dass man jetzt hier
nur für die entsprechenden beziehungsweise hier für die entsprechenden Zuteilung,
Aufteilung der Prozessoren und Zuordnung der Daten.
So, der Algorithmus ist in der Zeitkomplexität von diesem Teil hier optimal.
Jetzt wollen wir sehen, was da nochmal genau hintersteht.
Also dieser Algorithmus hier im Grunde genommen.
So, und jetzt die Frage, woher kommt das?
Wir haben schnelles Mission von Folgen der Länge M.
Und jetzt kann man sich mal anschauen, was da passiert.
Das sind die entsprechenden Zahlen, die wir eben ja schon gesehen haben.
Und jetzt muss man einfach nochmal gucken,
was ist hier jetzt wichtig
Und also erst mal die länge Länge der Geschichten da.
Und dann immer die Höhe des Baumes. Das sind so
die Punkte drin. Und die Folgen haben immer die Länge zwei Hochhaar,
die wir da drin stecken haben, die wir jedes bearbeiten müssen,
weil die Länge ist ja jeweils zwei Hochhaar,
nämlich hier ist null, ist eins.
Und hier ist zwei Hocheins, zwei und so weiter,
weil wir sie ja immer genau immer unten kommen,
von unten kommen, mit ein, zwei, vier, acht zusammenmischen.
Entsprechend ist das bei der Zeitkomplexität dann eben genau dieses Lock-Lock-2 hoch N.
Und das ist genau das Log von der Höhe.
H, den Rhythmus der Höhe. H, den wir
an Zeit brauchen dafür. Und das ist ein Log,
Log-in, weil das H ja wieder genau dieses Log-Logrythmus von N war.
Das heißt also, genau an der Stelle kommen wir jetzt also rein und sagen,
okay, gut, diese Höhengeschichte sagt uns,
wie hoch das Ding geht.
Wir kommen also relativ schnell da rein. Die Zeitkomplexität,
die wir brauchen, ist, log noch zwei hoch N.
Das war aufgrund der Zeit von diesem Mischen,
was wir vorher ausgerechnet hatten. Und dann aufgrund dessen,
dass das Haar eben genau Log von N ist,
kommen wir auf Log-in an der Stelle
entsprechend hin
So, und insgesamt kommen wir jetzt auf dieses Log-N mal-Block-In.
Wieso das? Jetzt haben wir geguckt, was bei
einem Teil ist. Wir müssen uns jetzt mal gucken,
was jetzt einmal dem ganzen Baum passiert.
Und es ist also die Zeit nochmal nach oben,
ja den Baum jetzt auch noch hochpaversieren.
Also das Log-In brauchen wir ja mal genau auf dieser Sache.
Wir gucken nur, was passiert auf einer Ebene.
Was sind da? Was ist da jeweils los?
Und die Anzahl der Ebenen sind dann eben genau Log-In nochmal
Schritte und dadurch kommen wir auf dieses Log-In von diesen
entsprechenden Teilen dabei
So, dann haben wir die Anzahl der Folgen,
die wir da drin haben, das N durch 2UM.
Das heißt, was für Operationen führen wir jetzt eigentlich durch?
Und jetzt kommen wir eben auf O von M. Wie kommen die
jetzt zustande? Naja, das ist O von 2 Hoch N,
mal N durch 2 Hoch N und das wieder N.
Entsprechend, wenn man da drauf guckt,
was man da eigentlich jetzt genau an Operationen, an Dingen bearbeiten muss,
weil aufgrund der Höhe kommt man jeweils hier rein und insgesamt muss man N mal durch 2 hoch N haben.
Das heißt, wenn wir die Anzahl der Operationen haben,
haben wir unten N und dann haben wir nochmal N und
dann kommen wir halt entsprechend auf diese zahlen und insgesamt
müssen das jetzt wieder für die Ebenen machen und kommen wieder entsprechend auf das N-Login.
So, aber auch das,
auch da den genauen Beweis und wie das genau funktioniert,
weil es mir anschaulich so in etwa erklärt,
wie ich durch diesen Baum und immer wieder und
weil es diese ist und weil ich einen Algorithmus einsetze,
weswegen klappt das Ganze jetzt mit diesen Zeitgeschichten.
Das heißt, die Komposition dieser Dinge ist schon
recht groß und man kann auch eine Menge Sachen machen und
damit bin ich jetzt an dieser Stelle durch