So, nach kleinen technischen Problemen kann es losgehen.
Also, Sortieren, untere Schranke oder keine untere Schranke.
Wir hatten ja letztes Mal uns Seepshot angeguckt und
das mal davor irgendwie Merch Sword und Quick Sword.
Und das mal davor irgendwie Insertion Sword,
also dieses Minmax Sword und solche Sachen.
Und erstmal wurden die Laufzeiten immer besser. Und das wäre
irgendwie von ON-Quadrat auf ON mal Login gekommen sind.
Jetzt kann man sich irgendwie fragen, geht das noch schneller?
Also gibt es vielleicht gar keine untere Schranke fürs Sortieren
Das kann man sich schon überlegen. Irgendwas hat das untere
Schranke vielleicht zumindest sowas wie O von 1 oder so,
wird es wohl geben. Irgendwas werde ich wohl machen müssen.
Vielleicht sogar O von N, dass ich irgendwie weiß,
naja, jedes Element muss ich mir schon mal angeguckt haben oder so.
Aber die Frage ist halt, kriegen wir irgendwie so eine untere Schranke so hin,
dass es genau passt zwischen, besser als so kann es nicht sein.
Und wir haben einen Algorithmus, der genauso schnell ist,
dass wir, dann hätten wir die Lücke geschlossen.
Das ist halt quasi die Frage,
kann man als untere Schranke sowas angeben,
wie Omega von N mal Login, dann weiß man die Verfahren,
die wir das bisher hatten, die ein ON mal Login,
wahnsinnig optimal.
Oder kann man als untere Schranke nur sowas angeben wie Omega
von N und kann sogar noch einen Algorithmus finden,
der NO von N ist,
dann lernt man das
so optimal
Ja, die ersten Folien wiederholen nochmal die ganzen Sortierverfahren,
die wir bisher hatten und damit so die Vorlesungen, die wir am Anfang hatten.
Das war so das Problem gegeben, so eine Sequenz von Endzahlen.
Da steht immer noch Zahlen, allgemein so N-Objekte,
die man irgendwie miteinander vergleichen kann, damit man damit arbeiten kann.
Dann hatten wir dieses Min-Mux-Sort oder eben Selection-Sort,
was immer irgendwie das größte Element rausgesucht hat und in das Ergebnis Array irgendwie nach hinten getan hat.
Und dann die vorletzte Stelle, drittletzte Stelle und so weiter.
Dass wir in UN-Quadrat und dann haben wir uns als nächstes ein bisschen clevererer dieses Insurgent-Sort angeguckt,
was so arbeitet,
wie wie das Sortieren von Karten beim Kartenspiel oder sowas,
dass man immer eine Folge von sortierten Karten schon hat und dann die nächste halt einsortiert.
Auch in UN-Quadrat, das haben wir damals so in der ersten,
zweiten Vorlesung als Aufhänger genommen, um uns zu müssen über schleifende Varianten und so zu unterhalten.
Also Korrektheit von Algorithmen. Das ist Bubble Sword,
den haben wir gar nicht explizit gehabt,
den hat aber einer mal zwischendurch irgendwie erwähnt,
was man halt immer irgendwie zwei Elemente vergleicht und dann eben
tauscht und das dann quasi das Größte wie so eine Blase
im Glas nach oben wandert und danach wechselt das Zweitgröße
nach oben und so weiter.
Auch in UN-Quadrat
Die sind also alle ein UN-Quadrat und da hat man sich gefragt,
naja, okay, die sind alle so ein bisschen Brootforce-artig,
auch wenn bei Bubble Sword oder in Search and Sword schon so eine Idee hinter steckt,
aber die werden alle nicht schneller,
als wenn ich alle Elemente mit einvergleiche.
Also die bleiben alle so ein ON-Quadrat.
Und dann war die Frage, geht das schneller?
Und dann haben wir halt in der zwei,
in der zweiten Hälfte der zweiten Vorlesung oder in der dritten Vorlesung
haben wir uns dann über die weiten Conquer-Verfahren unterhalten und dann eben über Merch Sword und Quick Sword.
Und die weiten Conquer-Verfahren da war eben die Idee,
ich habe ein großes Problem,
ich teile es irgendwie in mehrere kleinere Probleme,
löst die rekursiv und füge das dann zur Lösung des
großen Problems irgendwie wieder zusammen
Ja. Und dann die beiden Ansätze,
die wir da kennengelernt haben, waren Merch dort,
ein Quicksalt, die sich vor allem auch darin unterschieden haben,
wo bei diesen Teilen und beherrschen die schwere Arbeit ist.
Also bei Merch Thord war die schwere Arbeit nachher beim dritten Punkt,
beim Verbinden der Teillösungen und beim Quicksalt war die schwere Arbeit
beim ersten Punkt, beim Teilen des Hauptproblems in Teilprobleme.
Merch tot die Idee,
ich teile die Angaben in zwei gleich große Hälften,
löse die beiden Teilprobleme unabhängig und kombiniere das dann wieder zusammen.
Und dieses Teilen gilt halt immer ganz einfach,
weil ich einfach in die Mitte springe, sage,
da teile ich und dann habe ich zwei
halb so große Arrays
Deswegen sieht das ja auch relativ einfach aus und
dann war eben die Idee für dieses Merch,
dass man zwei sortierte Listen hat und dann immer aus jeder Liste das kleinste Element raussucht,
in die Ergebnisliste tut und weitermacht.
Ja. Wer hat auf dem Aufgabenzettel die 4-3
-2 gemacht, dieses mit dem Konflikt erzählen?
Wer hat das hingekriegt? Einer, ja, schön.
Wie habt ihr das gemacht? Oben rechts?
Wie hast du
es gemacht
Aber dann seid ihr ja ein UN-Quadrat, oder?
Ein Vergleich ja jedes mit jedem. Völlig gemerkt. Genau
. Genau, genau. Was im Grunde genommen das Gleiche
wie bei Mersh Thought, also so quasi die eine Idee ist,
die gleichzeitig noch mitzusortieren. Und die zweite Idee ist,
wenn ich dann diese zwei Hälften habe,
und ich finde jetzt irgendwie einen Konflikt, dann muss das Element,
das mit dem anderen Konflikt hat,
mit all den anderen da auch einen Konflikt haben,
weil die dann ja auch alle klein oder größer
oder was auch immer sind
Und dann funktioniert das. Genau, muss man dann noch beweisen,
aber im Grunde genommen kann man das hier nehmen und muss an zwei,
drei Stellen noch sagen, und ich zähle noch die zusätzlichen Konflikte,
und dann hat man das, also auch devide in Conka-Verfahren,
mit einer Anpassung von Emerging.
Wer es hingekriegt hat, Glückwunsch, das war schon ein bisschen kniffliger, ne? Ja,
dann Quicksawd, da war, wie gesagt,
das Problem beim Teilen, dass man irgendwie dieses,
das große Feld AP bis R hat man in zwei Teile geteilt,
AP bis Q minus 1 und Aku plus 1 bis R,
wobei Aku eben dieses Pivo-Element ist.
Und alles, was links davon ist,
ist kleiner, alles, was rechts davon ist,
ist größer
Und die Aufgabe ist dann eben,
am Anfang wähle ich mir ein Pivo-Element,
wir haben das am weitesten rechts stehende im Arry genommen und
dann muss ich eben über alle Elemente irgendwie rübergehen und gucken,
dass ich das anständig aufgeteilt kriege.
Und beim Verbinden ist dann nachher nicht mehr viel zu tun,
weil dann eben alle schon quasi sortiert ist.
Ja, sah dann so aus, auch wieder zwei rekursive Aufrufe.
Und hier war aber das Problem,
man kann hier beim Bestimmen von Kuh und dann hier beim Aufteilen nicht garantieren,
dass man immer in zwei halb so großen Arrays ist.
Deswegen klappt das nicht mit so einer schönen Rekurrenzgleichung wie beim Merch Thord,
sondern man kann eine schlimmere Rekurrenzgleichung haben und deswegen läuft das
eben nicht zwingend in ON mal Login,
sondern eben im Worst Case in ON-Quadrat
Da haben wir nochmal das für partischen. Genau. Genau,
das waren die beiden Ideen mit die Weiten Conquer. Und dann haben wir gesagt,
das war sozusagen der Angriffsvektor, dass man gesagt hat,
naja, wir haben dieses Problem, wir wollen es irgendwie anders lösen,
können wir irgendwie mit einem anderen Algorithmenparadigma da rangehen.
Bisher hat man so eher so Brutforce gemacht und hat versucht,
sich was Cleveres zu überlegen. Und dann weiß man,
wie aus der Literatur, hey,
es gibt auch sowas wie die Weite in Konga,
kann ich das benutzen, um das effizient zu lösen.
Und dann kommen eben zwei solche Ansätze raus. Einer davon ist gut,
der andere sieht zuerst nicht so gut aus,
also Quicksult mit dieser Worst-Case-Love-Zeit von UN-Quadrat, sieht ihr vielleicht erstmal nicht so gut aus.
Und andere Angriffsvektor ist, dass man eben sagt,
okay, ich versuche es nicht mit so einem Algorithmenparadigma,
sondern ich versuche eben irgendwie mit einer clevereren Datenstruktur
das Problem zu attackieren
Und das kann man dann eben mit Heepsort machen,
dass man irgendwie sagt, okay, ich konstruiere mir explizit eine Datenstruktur,
die sich gut eignet, um dieses Problem zu lösen.
Das waren dann eben diese Heeps. Und die Idee beim Heep war eben,
dass man einen binären Baum hat oder einen fasbinären Baum,
bei dem eben immer der Vaterknoten größer ist als seine beiden Kinderknoten.
Und dann ist die Wurzel der größte Knoten,
dann kann ich halt die Wurzel nehmen,
weil es das ist der größte Knoten, das ist mein größtes Element.
Und dann sorge ich dafür, dass Heeb-Eigenschaft wieder sichergestellt ist
und dann kann ich mir wieder das größte Element nehmen,
immer so weiter. Deswegen beim Heepsort,
am Anfang baue ich mir einen Hieb auf, Und dann gehe ich,
halt das Area einmal komplett durch und tausche immer die Wurzel aus mit dem letzten Element quasi,
mit dem, was im Baum ganz rechts unten ist,
schneidet das Element ab.
Dann habe ich quasi die Wurzel jetzt isoliert und dann füge ich eben wieder diese,
fühle ich wieder diese Maxipify-Operation auf die Wurzel aus.
Die ist ja jetzt nicht mehr das größte Element.
Also lasse ich sie irgendwie im Baum nach unten wandern.
Und die einzelne Operation da dieses Bild Maxib,
das ist eben davon ausgegangen, wenn ich am Anfang Baum habe,
die Blätter sind schon hiebs, das ist okay,
aber sobald ich das erste Element habe,
was kein Blatt ist, das ist vielleicht kein Hieb mehr.
Deswegen,
wenn ich auf das wieder diese Maxibify-Operation an und sorge dafür,
dass das dann auch ein Hieb ist und dann arbeite ich
mich immer weiter im Baum
nach oben
Deswegen hier dieses Downtour nicht irgendwie von A bis,
wer von 1 bis Länge, sondern eben, dass man das I runterzählt.
Genau, und bei Maxipify war dann eben die Idee,
ich vergleiche das Element,
was jetzt die Wurzel von so einem Baum ist und eben
unter Umständen nicht das größte Element vergleicht mit seinen beiden Kindern.
Und wenn eins der Kinder größer ist,
dann tausche ich das eh mit dem größten der beiden Kinder
aus und lasse so dieses Element nach unten wandern im Baum,
bis die Hippie, bis die Hieb-Eigenschaft wieder erfüllt ist.
Das ist so aus Kot. Sieht es ein bisschen länglich
aus, aber viel passieren tut er eigentlich nicht.
Hier in der Zeile 3 bis 7 wird halt im Grunde
genommen einfach nur bestimmt,
welches das größte Element ist und damit das eben ausgetauscht
Ja, in den Zeilen 3 bis 10 passiert das.
In 3 bis 10 wird das Größte irgendwie bestimmt.
So, das kennen wir jetzt alles. Also wir kennen jetzt beim ersten Bullet da,
wir kennen diese 1, 2, 3, 4 Verfahren,
die in ON-Quadrat sind, noch mit der Anmerkung,
Quicksort ist zwar im Worst Case in ON-Quadrat,
aber im Average Case eben in diesem ON mal Log-in und schön schnell,
also eigentlich vergleichbar mit Merch Thord.
Und wir kennen auch welche,
die in ON mal Log-in sind, Merch Thord und Heepsword.
Und die Frage ist, geht es noch schneller? Kann ich das,
kriege ich das irgendwie in, keine Ahnung, oh,
Wurzel-En mal Log-In hin oder in OON mal Log-Log-In oder in ON,
ON wird wahrscheinlich schwierig so,
aber vielleicht geht ja in ON mal Log-Log-In,
das wäre auch cool
Das meint ihr, dann geht das noch schneller.
Willst du das nur Hallo sagen? Ihr sollt es ja
auch nicht wissen, ihr sollt eine Meinung zu
diesem Thema haben
Nee, wenn keiner was sagt, heißt das, ihr braucht nur Bedenkzeit.
So 30, 40 Minuten, ich kann mir einen Kaffee holen gehen.
Alles super. Weiß ich nicht, vielleicht. Wer meinte denn,
wer könnte sich denn vorstellen, dass das noch schneller geht?
1, 2, 3, 4, 5, 6, 7.
Wer kann sich vorstellen, dass das nicht mehr schneller geht,
dass ON mal Login so eine Grenze irgendwie ist?
Der Rest ist sich unsicher. Tatsächlich, also erstmal kann man sich überlegen,
Bisher sortiert, wir haben ja immer Zahlen sortiert so.
Jetzt hatte ich gesagt, naja,
eigentlich wollen wir Objekte sortieren, die irgendwie vergleichbar miteinander sind.
Also, dass man irgendwie diese Vergleichsoperation hat, kleinergleich oder irgendwie sowas.
Und dass man die benutzt. Und wenn ihr nochmal im Gedanken,
deswegen waren die eben da, wenn ihr diese ganzen Sortierverfahren nochmal durchgeht,
bei all diesen Sortierverfahren habe ich nur so eine Vergleichsoperation benutzt.
Ich habe nie so sortiert, dass ich gesagt habe,
ich gucke mir mal das Element an und wenn das Element zufällig,
was weiß ich, die Zahl 5 ist,
dann mache ich damit das und das.
Irgendwann in der ersten oder zweiten Vorlesung hat auch mal jemand gesagt,
ich glaube, das warst du,
wenn ich in Zahlen habe,
und das sind gerade die Zahlen von 1 bis
So, dann sind die ganz schnell zu sortieren, weil ich dann quasi,
dann mache ich mir ein Ergebnis, Arry von 1 bis N.
Und das iTe-Element kommt halt an die IT-Stelle.
Ist klar. Jetzt kann man sich überlegen,
kann man das irgendwie verallgemeinern, wenn ich weiß,
ich habe irgendwie viermal Endzahn und alle sind in diesem Raum 1 bis Ende,
kann ich das irgendwie verallgemeinern oder so.
Da arbeite ich dann aber mit dem Wert der Elemente.
Da muss ich dann damit arbeiten, dass es wirklich
eine Zahl ist. Wenn ich das nicht machen will,
sondern wenn ich bei all diesen, wenn ich das so machen will,
wie bei all diesen Verfahren und mit Vergleichsoperationen arbeiten will,
dann kommt raus, es geht tatsächlich nicht schneller.
Also dieses Endma Login ist eine untere Schranke dafür
Bei vergleichenden Sortierverfahren. Das wollen wir uns jetzt nochmal genauer angucken.
Und dann können wir mal gucken, ob wir die Grenze
nicht noch durchbrechen können mit der Idee von eben.
Erstmal hier vergleichende Sortierverfahren, das sollen solche sein,
die eben auch vergleichen zwischen den Eingabeelementen basieren.
Dass ich irgendwie sagen kann, das Element A ist kleiner
gleich dem Element B, in dem Merry.
Mir mache ich nicht. Guckt mir nur so,
ich vergleiche an. Und für die zeigt man eben,
dass es diese untere Schranke von N mal Login gibt.
Und damit sind dann dieses Merch-Sot und Heep-Sot asymptotisch optimal.
Und da nochmal betont, asymptotisch,
weil das eben so eine Worst-Case-Analyse und so eine Analyse für,
wenn N immer größer wird und so.
Sonst kann man es eben auch sehr gut haben. Hatten wir,
glaube ich, letztes Mal auch einmal kurz diskutiert,
dass in Search and Sword ziemlich cool ist,
wenn das Array schon fast komplett sortiert ist oder so.
Dann ist das toller als Heep-Sword oder so
Genau, so wie machen wir das? Erstmal überlegen wir uns,
die Tests hier sind alle möglich, das sind alles so Vergleichstests.
Und aufgrund dieser Tests überlegen wir uns,
wie die Reihenfolge der Elemente sein muss,
wenn AI kleiner als AJ ist, dann ist klar,
dass AI irgendwie im Ausgabe Arry 4aJ kommen muss.
Und jetzt, wie gesagt, da könnt ihr euch noch mal überlegen,
dass das bei allen bisherigen der Fall war.
Bei Insurgent Sword, ich habe immer geguckt, meine neue Karte irgendwie,
ist die kleiner oder größer und demnach habe ich sie einsortiert.
Bei Merch Sword musste ich beim Merchant immer gucken,
welches ist das kleinste Element,
um das dann die richtige Stelle im Ausgabe Arry zu tun.
Beim Quick Sword habe ich immer geguckt, was ist größer
oder kleiner als mein Pivo-Element und habe das dementsprechend sortiert.
Und beim Heep Sword, ja,
also bei einem herabsteigenden Baum oder so,
da habe ich auch die ganze Zeit Vergleichsoperationen
So, und jetzt halt die Frage,
wie kann man das ausnutzen, wenn ich solche Vergleichsoperationen mache?
Erstmal kann man sich ein bisschen einschränken und kann sagen,
wir gehen nur von dieser Vergleichsoperation aus.
Wir gehen mal davon aus, alle Elemente sind ein paar
weise verschieden, dann brauche ich nur eine Vergleichsoperation.
Ich habe jetzt nie hier genommen, AI,
kleiner AJ würde auch funktionieren, weil gleicher gibt es dann ja nicht mehr,
wenn die alle Paarweise verschieden sind.
Aber so von der Idee her, wir schränken uns ein bisschen ein,
sagen alle Elemente so ein paar,
weil sie verschieden sein und dann sieht das so aus.
Ist keine Einschränkung, weil wenn ihr eine Worst-Case-Analyse machen wollt,
dann kann eben ja gerade dieser Fall auftreten,
dass ihr irgendwie paarweise verschiedene Elemente habt.
Das heißt, wenn dafür schon auftritt,
die untere Grenze ist N-Ma-Login,
dann ist es für einen allgemeinen Fall ganz bestimmt die
untere Grenze
So, und was man jetzt machen kann,
jetzt kann man diese vergleichenden Sortierverfahren als Entscheidungsbäume betrachten.
Und das gucken wir uns mal an hier.
So sieht das dann aus. Die Idee ist,
wir halten jetzt mal so ein Verfahren fest in Search
and Ford mit Eric Größe 3, also relativ einfach.
Wir haben jetzt ein Service, wir kriegen ein Arry mit
drei Elementen und wir wenden darauf in Enterchant Sword an.
Und beim Entscheidungsbaum schreiben wir uns jetzt auf,
welche Vergleiche wir immer machen und was die Folge davon ist.
Und wir haben ja nur eine Vergleichsoperation, kleiner gleich.
Das heißt, entweder ist ein Element kleiner gleich dem anderen,
dann passiert irgendwas Neues oder ist es größer,
dann passiert wieder irgendwas Neues.
Das heißt, wir kriegen so einen binären Entscheidungsbaum.
Und hier notieren wir uns jetzt immer,
welche Elemente wir miteinander vergleichen
Und wenn ihr Insurgent Sword habt, am Anfang das erste Element,
da passiert noch gar nichts. Jetzt nehmt ihr das zweite Element
und guckt, ob das kleiner ist als das erste.
Falls ja, tauscht ihr die beiden. Falls nein,
lasst ihr alles so und fangt, macht mit dem dritten weiter.
Das heißt, wenn ihr, wenn das erste kleiner
gleich dem zweiten ist, dann tut ihr ja nichts.
Und als nächstes würdet ihr dann ja das dritte Element nehmen
und das mit dem zweiten vergleichen.
Das ist dann der Knoten da links da drunter.
Wenn das aber so ist, dass eins und zwei,
das, Moment, das zwei kleiner ist als eins,
dann würde die zwei da ja hin,
wo die eins ist.
Die beiden würden
ihren Platz tauschen
Und als nächstes, und seid ihr damit fertig,
als nächstes nehmt ihr die dritte Karte, wollt ihr einsortieren?
Und dann würdet ihr die dritte mit dem jetzt zweiten,
was aber ja die frühere erste war, vergleichen.
Und dann kriegt ihr halt so einen Entscheidungsbaum hin und an
den Blättern hier steht immer die Permutation, die rausgekommen ist.
Also wenn ihr festgestellt habt,
eins ist kleiner gleich zwei und zwei ist kleiner gleich drei,
dann braucht ihr irgendwie nichts ändern, sondern ihr habt schon sortiertes Arry.
Wenn ihr irgendwie was anderes rauskriegt, wenn ihr rauskriegt,
die eins ist aber größer als die zwei gewesen,
dann muss die eins ja irgendwo anders hinsortiert werden und bei
all diesen Blättern steht eben,
wo die einzeln sortiert wurde,
die zweite oder dritte Stelle
Genau, das ist da die Idee bei diesem Entscheidungsbaum.
Und man abstrahiert quasi von dem Algorithmus nur auf die Vergleichsoperation.
Alles andere ist einem für den Moment egal. Man weiß
, es gibt diese Vergleichsoperation. Und wenn man da schon
sagen kann, es gibt da irgendwie N-Ma-Log and viele,
dann reicht das ja schon.
Genau. Und hier ist nochmal, ups. Ja,
da kommt es gleich. Entschuldigung, also ein so ein Knoten,
IJ stellt eben Vergleich zwischen dem Element AI und AJ
da,
das ist klar
Und dann wird eben im linken oder rechten Taibaum-Waute weitergemacht.
Und der Weg von dieser Wurzel zu einem Blatt, also sowas hier,
einen so einen Weg von dieser Wurzel irgendwie zu so einem Blatt,
stellt eben eine Ausführung von diesem Algorithmus dar, mit dem Ergebnis hier unten.
Also das Blatt sagt mir dann quasi, wie die ursprünglichen
Elemente angeordnet sind, damit das Area jetzt sortiert ist.
Genau, und ein Blatt ist eben dann mit dieser Permutation gekennzeichnet.
Wenn man sich das jetzt nochmal in diesem Beispiel hier anguckt,
wenn man unten rechts steht jetzt, dass Area,
was wir hatten, wir hatten sieben, neun,
vier als Arry, wenn man darauf in Searchins Hot anwendet,
dann würden als Vergleichsoperation genau dieser jetzt rosam markierte Pfad
da abgearbeitet werden
Zuerst stelle ich fest, das erste ist kleiner gleich,
dem zweiten. Sieben ist kleiner gleich neun.
Dann stelle ich fest, neun ist größer als vier.
Also ist nächstes Vergleich ja das zweite mit dem dritten.
Jetzt tausche ich die beiden ja aus.
Jetzt habe ich neun und vier getauscht. Und jetzt vergleiche
ich ja sieben mit vier. Also jetzt vergleiche ich nochmal
das erste mit dem dritten und tausche die auch nochmal,
sodass ich dann diese Reihenfolge 3, 1, 2 rauskriege.
Also genau vier, sieben, neun.
Klar. Was kann man jetzt machen? Was meint ihr?
Wie kommt man jetzt auf die Uhr in mal Login?
Was kann man ausnutzen? Ja,
wie man auf die ON mal Login kommt,
ist schwer,
aber was kann man ausnutzen
Also. Genau, und was noch,
was kann man dafür benutzen? Also ihr seid ja,
man kann sich jetzt die Tiefe des Baums,
die kann man irgendwie benutzen oder die Höhe oder was, oder?
Höhe oder Tiefe. Genau, wenn man jetzt nur sagen
würde, die Höhe, dann hilft mir das dann.
Ich baue noch irgendeinen Wert, mit dem ich arbeiten kann.
Mit welchen kann ich noch arbeiten? Ja,
ist ein Bienenärer Baum, reicht mir auch noch nicht,
weil in ihrer Baum kann auch beliebige Höhe haben.
Ich brauche noch irgendeine Schranke, wo weiß ich noch,
von was weiß ich noch, wie viele es gibt.
Die Eingabelänge weiß ich noch, ja, das hilft mir fast.
Wie viele Wurzeln kann es geben? Eine, okay,
das hilft mir jetzt irgendwie nicht. Wie viele Genau,
die Blätter hier. Ich weiß, wie viele Blätter es geben muss.
Wupps, da. Warum weiß ich das? Weil die
Array-Elemente können ja am Anfang beliebig sortiert vorliegen. Das heißt, jede Permutation muss als Ergebnis möglich sein. Wenn irgendeine nicht möglich wäre,
also wenn zum Beispiel die Permutation, die ganz rechts unten da,
wenn 3-2-1 nicht möglich wäre,
dann wäre es nicht möglich, die Elemente,
die am Anfang eben genau so sortiert sind, dass diese Permutation bräuchte,
nämlich dass das Dritte das Kleinste ist, das Zweite,
das Mittlere und das Erste, das Größte,
die Permutation wieder richtig herzustellen,
also wieder zu sortieren.
Das heißt, alle Permutationen müssen als Blätter vorliegen
Und damit kann ich arbeiten. Ich weiß jetzt,
ich habe einen Baum, der binär ist,
der hat N-Fakultät viele Blätter, also N-Elemente habe ich,
dann gibt es Endfakultät, viele Permutationen.
Und jetzt kann ich mit der Höhe arbeiten. Jetzt rechne ich mir aus,
die Höhe des Baumes ist dann die Worst-Case-Laufzeit,
weil die Höhe des Baumes sagt mir,
den längsten Pfad von der Wurzel zu einem Blatt.
Und das ist die Worst-Case-Laufzeit des Algorithmus. Ups. Genau
, da steht es auch nochmal, wichtige Erkenntnis.
Jeder Korrektor ist Tieralgorithmus, muss in der Lage sein,
jede Permutation seine Eingabe zu erzeugen.
Und das Wichtige hier ist auch,
ist eine wichtige Erkenntnis, aber die ist vor allem
auch beweisbar
Relativ schnell, aber so wie ich es eben gesagt habe,
kann man das eben beweisen, dass das tatsächlich so ist.
Ansonsten, wenn man untere Schranken bewahrt,
wenn man da erstmal so irgendwie rangeht und versucht,
nur untere Schranke zu beweisen,
dann geht man oft von irgendwelchen Sachen aus,
die vielleicht gar nicht stimmen müssen.
Deswegen, solche Sachen müssen bewiesen werden,
sonst habt ihr nachher keine untere Schranke. Keine Ahnung,
zum Beispiel bei der Matrix-Multiplikation wird man intuitiv auch erstmal denken,
naja, ich muss ja irgendwie Matrizen addieren oder sowas.
Also gehe ich mal davon aus,
dass das passieren muss oder so, das ist aber falsch.
Schnellster Algorithmus dafür, der arbeitet mit irgendwie einer Subtraktion von Matrizen
als erstes. Deswegen so Sachen irgendwie auszuschließen oder zu behaupten,
das muss auf jeden Fall im Algorithmus passieren.
Ist irgendwie schwierig, deswegen haben wir auch so ein Problem,
untere Schranken zu beweisen. Hier geht's aber,
hier können wir irgendwie sagen, diese Permutation müssen wir
auf jeden Fall hinkriegen können
Und die Eigenschaft ist auch beweisbar, deswegen können wir damit
schön arbeiten. Genau, das können wir jetzt benutzen,
notwendige Bedingungen für die Korrektheit ist, dass dieser Entscheidungsbau
mindestens Endfakultät von der Wurzel aus erreichbare Blätter haben muss.
Ja, und das kann ich jetzt benutzen und das jetzt,
warum steht denn die Folie noch?
Nötig, wie vielleicht auf dem nächsten Fahrrad im Entscheidung.
Das hast du wieder schon erzählt. Genau, die Anzahl
der Vergleichsoperationen im schlechtesten Fall entspricht der Höhe des Entscheidungsbaums.
Und der muss mindestens Endfakultät Blätter haben.
Da wollte ich hin
Endfakultät, also Ende ist die Angabelänge, Endfakultät per Mutation gibt es.
Das heißt, die Anzahl der Blätter muss mindestens so groß sein wie dieses Endfakultät.
Und die Anzahl der Blätter ist eben höchstens so groß wie,
wenn ich einen Vinäherbaum der Höhe habe, wie zwei UH.
Ja, Lugarithmus ziehen, also was mich jetzt ja interessiert,
dass L interessiert mich gar nicht so,
was mich interessiert, ist,
dass Endfakultät kleiner gleich zwei hochhaar ist und ich will das irgendwie zu haar auflösen.
Dann habe ich Haar, größer gleich, Lugarithmus von Endfakultät.
Und da kann ich jetzt mit Sterlinger Formel und sowas das hier Schluss folgern.
Lugarithmus von Endfakultät ist in Täter von N mal Login,
kann man mit Sterlingsform, steht auch in der Formelsammlung drin,
kann man das abschätzen.
Und dann weiß man, dass dieses Haar mindestens so groß sein muss,
wie irgendeine konstante Zehma in Maloggen. Ich nehme mal an,
der ist kurz ins Patriot, der Sterlingsform, der zerspannt.
Weiß ich. Ja, aber die fliegt hier auch irgendwie raus.
Ich glaube, das macht nichts. Also ich bin mir
nicht sicher, aber ich glaube, das macht nichts.
Müsste ich einmal genau durchrechnen. Also da, wenn man,
das kann man jetzt einfach als Wissen benutzen,
dass man weiß, Login-Fakultät ist so beschränkt.
Und dann hat man die Schlussfolgerung, die wir haben wollen.
Wenn man jetzt genau wissen will,
warum das hier gilt, ja,
da muss man einmal tief reinschauen und einmal tief reinschauen in
diesen Beweis von der Sterlings-Formel
Ja, fertig, ne? Damit haben wir das. Klar, ne, ihr überlegt euch irgendwie, ihr habt vergleichende Sortierverfahren. Dann sagt ihr,
wenn ich vergleiche, ein Sortierverfahren habe,
dann habe ich ja so eine Vergleichsoperation, kleiner gleich,
und kann mir, das ist jetzt so die kreative Idee,
dass man sagt, naja,
jetzt kann ich irgendwie mit so einem Entscheidungsbaum arbeiten,
um den Algorithmus abstrakt darzustellen, egal wie der Algorithmus intern realisiert wird,
für jeden Algorithmus, für jede Ausführung dieses Algorithmus ist,
gibt es irgendwie solche Entscheidungsbäume.
Damit kann ich arbeiten, dann weiß ich irgendwie,
unten müssen alle Permotationen auftreten bei den Blättern,
also muss es entfakultiert viele Blätter geben,
Und dann habe ich dieses Endfakultät, kleiner gleich L,
kleiner gleich zwei Hochhaar.
Und dann komme ich zu dieser Schlussfolgerung, das Heepsword und Merch Sword optimal sind.
Fragen? Gut. Dann kann man sich jetzt fragen,
naja gut, jetzt haben wir so eine Grenze,
wie der Mensch so ist, naja,
jetzt haben wir eine Grenze, jetzt durchbrechen wir die halt trotzdem.
Aber wir wissen so, im Allgemeinen können wir die jetzt nicht durchbrechen,
was man jetzt versuchen kann, ist,
man kann vergleichende,
vergleichende Sortierverfahren machen und die hier versteckte Konstante,
die kann man
möglichst klein machen
Also so ein Verfahren, das irgendwie in tausendmal End-my-Log-in arbeitet,
ist ja irgendwie schlechter als eins,
was in zweimal in mal Log-in arbeitet.
Von daher kann man an der Stelle rumspielen. Oder man kann sagen,
wenn ich das hier wirklich irgendwie drücken will,
also wirklich dieses End-my-Log-in, dann muss ich irgendwie mit was anderem rangehen.
Dann muss ich versuchen, das mit nicht vergleichenden Sortierverfahren zu machen.
Nicht vergleichende Sortierverfahren sind nicht mehr so allgemein,
weil ich dann irgendwie eine Eigenschaft der Elemente benutzen muss.
Aber in vielen Fällen kann ich das vielleicht machen.
Und eine Idee ist jetzt, dieses Counting-Sort,
das wollte ich noch einmal vorstellen. Wir gehen von diesem
Vergleichenden Sortierverfahren weg und nutzen jetzt eine Eigenschaft von Elementen.
Und bei Counting-Sort gehen wir davon aus,
dass wir irgendwie so eine Zahl K haben und
alle Elemente AI sind irgendwie zwischen 0
Wir werden nachher sehen, dass das nur dann wirklich Sinn macht,
wenn dieses K und die Anzahl der Elemente irgendwie sinnvoll sind,
weil das Verfahren wird gleich von dem K abhängen.
Wenn ich jetzt zwei Zahlenwerte habe,
irgendwie 4 und 10.000 und ich dann irgendwie sage,
oh, das ist jetzt so ein O von K,
also ein O von 10.000 oder so, da hilft mir das nicht viel.
Normalerweise hätte ich zwei Elemente ziemlich schnell sortiert.
Ich gucke sie mir beide an und bin fertig.
Also das K hier, das wird nachher irgendwie in sinnvollen Fällen,
wird das K und die Anzahl der Elemente ungefähr ähnlich sein.
Jetzt das Verfahren? So ähnlich wie diese,
ursprüngliche Idee, die wir mal hatten,
dass man sagt, wenn ich Ende Elemente habe,
zwischen Null und Ende und alle sind verschiedene,
dann weiß ich aber dazwischen eins und Ende und weiß,
ich habe genau die Elemente eins, zwei, drei,
vier, 5, 6, 7,
8 bis N und dann kann ich die halt direkt an den richtigen Index machen.
Das wird jetzt verallgemeinert, indem man für jedes dieser AIs
die Anzahl der Elemente bestimmt, die kleiner als AI sind.
Wenn jetzt zum Beispiel die drei, fünfmal auftreten kann oder so,
dann kann ich nicht mehr die drei direkt an die dritte Stelle setzen,
sondern dann bilde ich die irgendwie vielleicht ein paar Stellen mehr,
weil die gibt es jetzt fünfmal.
Und die vier kann auch nicht einfach an die vierte Stelle,
sondern erstmal kommen ja die ganzen dreien und dann kommt erst die vier.
Deswegen brauche ich diese Anzahl der Elemente, die kleiner sind. Genau,
und im Ausgabe Arry ist dann Wenn es M-Elemente gibt,
die kleiner als AI sind,
dann sind quasi die Stellen von B1 bis BM im Ausgabe-Erry,
die sind alle weg.
Da müssen ja die ganzen Elemente, die kleiner sind,
hin. Und an der M plus 1 Stelle,
da kann dann mein erstes AI-Element hin. Und dann kommen
eben alle diese AI-Elemente, so viele wie das eben sind.
Und dann mache ich weiter. So sieht der Algorithmus aus.
Gerade wenn ich das zu zweit habe. Nee, du willst ja,
also an die gleiche Stelle willst du sie nicht tun,
Ja, genau. Also die Idee ist ja auch,
also erstmal, du hast vielleicht die Zahlen, so,
aber eventuell ist das ja ein größeres Objekt,
wo eben diese Zahl noch drin ist.
Also was weiß ich, du willst die Studenten nach Alter
sortieren und jetzt hast du 500 Studenten, die 20 sind.
So, und die willst ja jetzt nicht alle an die gleiche Stelle tun,
damit sich das fröhlich überschreibt und das nachher nur noch einschnitt, der 20 ist.
Sondern du willst sie irgendwie hintereinander wegsortieren. Was war die
Frage? Ja, das erste Element. Also du guckst jetzt,
bestimme für jedes AI, die Anzahl emde Elemente,
die kleiner als AI sind,
also für den einen Wert von AI, für jetzt die fünf,
gucke ich mir an,
wie viele Elemente sind kleiner als fünf
So, und jetzt nehme ich mir nach und nach alle Elemente,
die den Wert 5 haben und tue dir an die Stelle M plus 1, M plus 2,
M plus 3, M plus 4 und so weiter.
Also das ist da noch ungenau, das soll nur die Idee gerade transportieren.
Ja, das ist der ganze Code. Ich gehe dann einmal kurz durch,
der wird gleich auch noch mit einem Beispiel ausführlich durchgemacht,
aber man kann hier schon sehen, in den Zeilen 1 bis 3,
da wird einfach nur so ein C-Erry,
das ist quasi das C-Erry, C für Counting,
da werden gleich die Elemente gezählt, wie viele Elemente es gibt,
wird da gezählt.
Das wird erstmal am Anfang alles auf Null gesetzt
Dann, ach so, Moment, und das Ziel ist es,
das Ziel ist es, das AR zu sortieren,
das ARB wird das Ausgabe-Array sein und die Zahl K,
das ist eben diese Zahl, dass sich alle Elemente in A zwischen 0 und K befinden.
Deswegen brauchen wir so ein C-L-Array hier, das wird alles um 0 gesetzt,
dann in den Zeilen 4 bis 6,
da gehe ich jetzt das ARR durch und wenn jetzt an der Stelle AJ,
wenn er jetzt die Zahl 5 steht,
dann zähle ich an der Stelle,
an C5 wird ja die Anzahl der Fünfen gezählt,
Die wird jetzt um eins erhöht und immer so weiter.
Also an der Stelle, ja genau, an der Stelle C5
werden eben die Anzahlen der Fünfen, in dem RAR gezählt.
Wo ich gehe einmal das ganze RAR durch und zähle,
wie viele Nullen gibt es, wie viele Einsen gibt es,
wie viele Zweien, dreien, vieren, fünfen und so weiter.
Deswegen wird das ja am Anfang auf Null gesetzt,
weil es ist ja gar nicht sichergestellt,
dass im RAR alle Zahlen zwischen Null und K wirklich auftreten.
Jetzt steht also in diesem RAC an der Stelle CI,
gerade wie viel Mal ist die Zahl I, in dem RAR gibt.
Als nächstes wird hier in den Zeilen 7 bis 9,
da wird das jetzt quasi aufsummiert, wenn ich wusste,
ich habe 2 Nullen, zwei Einsen, 3-2,
Ja, jetzt kann ich die quasi Stück für Stück auferdienen.
Ich weiß, ich habe 2-0, das ist okay. Dann weiß ich,
bei den Einsen, wenn ich zwei Einsen hatte,
dann habe ich also die 2-0, die ich hatte,
plus die zwei Einsen, also vier Zahlen, die kleiner gleich eins sind.
Und immer so weiter ideere ich das auf. Und das hier,
dieses sehr krüde B-C-A-J hier, das sorgt gleich dafür,
dass die Elemente AJ an die richtige Stelle einsortiert werden.
Und da gucken wir uns lieber ein Beispiel an hier. Also,
das sind die ersten drei Zeilen, eins bis drei,
da, nee, stimmt nicht,
bei den ersten drei Zeilen wird das alles auf null gesetzt,
das sind die Zahlen vier bis sechs.
Da gehe ich über das AR rüber
Wir fangen hier an. A1 ist 3,
also gehe ich hier an die Stelle C3 da und erhöhe die
irgendwie um eins, weil dann steht da der Wetteins.
Und das mache ich dann hier immer weiter und an der
Stelle A4 und an der Stelle A6,
da gibt es auch nochmal eine 3,
deswegen habe ich hier nachher den Wert 3. Eine 1 gibt es gar nicht,
deswegen wird das Element C1 in die zugegriffen und behält den Wert null.
Und für die anderen Elemente entsprechende. Also nach den Zeilen 4 bis 6
in dem vorherigen Algorithmus steht in dem Element CK,
gerade wie viele Elemente es in A gibt,
die gerade
den WK haben
Ja. Ja. Und hier seht ihr auch,
also sowohl in dem Teilstück als auch in allen anderen Stücken des Codes,
es wird an keiner Stelle ein Vergleich wirklich mal gemacht.
Hier wird tatsächlich die ganze Zeit nur mit dem Werten
der Elemente gearbeitet. Also hier in dem Code,
ihr findet hier nirgendwo eine Stelle, wo mal geguckt wird,
ist AI, kleiner gleich AJ oder sowas.
Das, was wir bei den vorherigen Algorithmen quasi ausschließlich hatten,
haben wir hier gar nicht.
Das, was wir hier zum Sortieren benutzen,
sind ausschließlich diese Zugriffe auf das Element,
auf das ARI,
auf das Arry-Element AJ
Also erster Schritt, ich schreibe mir in das REC eben,
wie oft es die Elemente gibt. Und jetzt,
weil diese Geschichte, jetzt gehe ich hier immer durch und
CI soll dann CI plus CI minus eins sein.
Das heißt, ich fange hier irgendwie an der Stelle hier an.
Und 0 plus 2, das heißt, es gibt zwei Elemente,
die kleiner sind als eins, dann irgendwie hier zwei plus zwei.
Also hier steht ja jetzt in zwei,
dann habe ich hier vier, dann weiß ich,
es gibt vier Elemente, die kleiner gleich zwei sind.
Und immer so weiter, das passiert jetzt im nächsten Schritt.
Ach so, was hier noch nötig ist, ah ja,
hier das REC, das soll mit null initiiert werden und
die anderen Aris werden immer mit eins indiziert.
Kriegt man natürlich auch weg,
wenn man da jetzt noch irgendwie so eine Rumspielerei hat,
aber dann wird das noch ein bisschen schwieriger,
den Code zu erklären.
Also hier, das Ari fängt mit Index Null
an und das Ari fängt mit Index 1 an
Ja, zweiter Schritt aufsummieren. Das Codestück. Deswegen fange
ich hier nämlich bei 1 und nicht bei null,
weil bei null gibt es ja noch nichts aufzusummieren.
Es gibt halt zwei Elemente, die kleiner gleich null sind.
Dann summiere ich hier auf, dann gibt es zwei Elemente,
die kleiner gleich 2, sind vier Elemente, kleiner gleich 2,
sind sieben Elemente, kleiner gleich 3 sind und so weiter.
Oh na gut, jetzt weiß ich halt,
jetzt kann ich halt nachher diese Dinger hier durchgehen.
Die Idee ist jetzt, wenn ich die Idee ist,
ich gehe dieses AR jetzt von links nach rechts durch und gucke mir immer das Element an.
Wenn das eine 3 ist,
dann greife ich jetzt auf das Element C3 zu,
also auf die 7. Und dann weiß ich ja,
es gibt sieben Elemente, die kleiner gleich drei sind.
Das heißt, ich stecke die erste drei,
die ich finde, an die Position 7 im Ergebnis Arry.
Und dann verringere ich das hier um eins. Und für
den Fall, dass da irgendwann wieder eine 3 kommt,
tue ich das an die sechste Stelle.
Wieder eine 3 Computers an die fünfte Stelle und so weiter.
Also vorhin hatte ich die Idee ja so erzählt,
dass man quasi ab BM plus eins das dann von links nach rechts auffüllt.
Das ist aber ein bisschen schwieriger, das so zu machen,
weil es gibt so viele Elemente, die sind kleiner gleich.
Und dann fange ich halt quasi hinten an,
wo ich meine drei hinschreiben will
Das ist das, was passiert hier. Ich nehme mir,
ich fange rechts an in die Mary, nicht links,
okay, ich fange rechts an.
Ich nehme mir dieses Element, greife darauf zu,
das hat den Wert null. Dann gucke ich in Zeh nach.
Bei null wurde mir gesagt, es gab zwei Werte,
die größer, die Kleider gleich null sind.
Das heißt, jetzt greife ich zu an die Stelle
B2 da und da schreibe ich mir die null hin.
Weil es gibt zwei Zahlen, die kleiner gleich null sind.
Das heißt, die Ary-Elemente 1 und 2 müssen mit null belegt werden.
Ja, und dann wird eben wichtig,
das hier nochmal um eins verringert,
damit ich dann eben hier sagen kann,
okay,
da muss auch
eine Null hin
Als nächstes kommt jetzt hier die Null,
dann greife ich wieder auf 10-0 zu,
das sagt mir jetzt, ich muss es an die Stelle B1 tun,
dann packe ich da die Null hin.
Und verringere das wiederum eins. Jetzt kommt irgendwie die drei,
jetzt gucke ich nach drei, da wird mir gesagt,
es gibt sieben Elemente, die kleiner gleich drei sind,
also kommt die erste drei an die Stelle B7.
Und dann wird, der wird hier noch um eins verringert.
Immer so weiter, ne? Bei A5 sehe ich jetzt,
da ist der W2 drin, also gucke ich bei C2 nach,
an welche Stelle soll das?
Das soll an die Stelle vier und dann wird sie
zwei noch um eins verringert
Ja, und jetzt der Grund,
warum er das verringert hat, jetzt wird hier für drei,
wird hier nachgeguckt, jetzt sagt er hier die Stelle sechs,
also muss es dahin.
Wenn nicht mehr an die Stelle sieben, deswegen wurde das
halt verringert. Zwei. Fünf. Drei. Fertig.
Sortiert. Nur mit Array zugriffen, also ohne irgendwas
zu vergleichen
Genau. Und im Grunde genommen ist das einfach eine Verallgemeinerung
dieser Idee, wenn ich Ende Elemente habe von 1 bis N.
Und dann, also wenn ihr euch überlegt hier,
dass wir in die Elemente 1 bis 8 nur in irgendeiner komisch sortierten Reihenfolge,
also in einer nicht sortierten Reihenfolge, in einer komischen Reihenfolge,
dann könntet ihr einfach das Element zugreifen.
Und wenn das eine 5 ist,
dann tut ihr das einfach an die Stelle B5. Ich meine,
da braucht man da noch nicht sortieren, wenn ich weiß,
ich habe die Elemente eins bis Ende,
dann kann ich auch einfach in der Vorschleife 1 bis N an die richtige Stelle im Airytoon und bin fertig.
So, da gibt es nicht viel zu tun
Und das ist halt die Verallgemeinerung quasi davon,
dass wenn ich weiß,
wenn ich jetzt irgendwelche Elemente mehrfach davon drin habe,
dann nehmen die eben nicht nur dieses eine Feld ein,
sondern irgendwie mehrere und dann verschiebt sich das quasi alles.
Wenn ich zwei Nullen habe, dann kann das nächstgrößere Element
eben nicht an die Stelle eins kommen oder so,
sondern muss dann eben erst den 2-0 Platz lassen
und dann kann das kommen.
Ja, da ist er nochmal Fragen
An der Stelle oder in der? Da. 2-
0, 2-2, 3-3,
eine 5. Ja, warum macht man das nicht?
Warte. Die Reihen von unseren gleichen Elementen
Ach so, jein, ich bin mir gerade nicht sicher,
ob du das gleiche meinst wie ich.
Fast die, also haben das alle gehört. Die Frage war,
warum macht man das nicht einfacher? Ich habe ja,
wenn ich dieses Arry bestimmt habe, dann weiß ich ja,
es gibt 2-0, 2-2,
3-3 in eine 5. Also kann ich auch einfach einmal über das REC rübergehen.
Schreibt mir zuerst 2-0 hin, dann 2-2,
3-3 in eine 5 in das Ausgabe Arry.
Bin ich fertig, ne? Das war die Idee, ne?
Ja, genau. Würde klappen, wenn das tatsächlich jetzt
nur um die Zahlenwerte ginge. Es geht ja meistens darum,
dass hier jetzt nicht einfach nur Zahlen drinstehen,
sondern dass da irgendwie ein Record oder so hast,
wo ein wichtiges Element dieser Zahlenwert ist.
Also Beispiel nochmal,
das Alter der Studenten
Und dann hast du zwar ne Mary irgendwie das Alter der Studenten,
du sortierst es nach dem Alter der Studenten,
aber dahinter steckt ja noch jede Menge.
Und dann musst du also dafür sorgen,
dass du tatsächlich diese Null irgendwie, ne,
nach vorne in das Ausgabe ärger schreibst, also die Null und alles,
was da noch mit dran hängt und nicht einfach nur den Wert Null.
Erster Grund und zweiter Grund, muss ich kurz nachdenken,
ob das stimmt. Das kommt zusätzlich noch dazu, genau,
das ist ganz lustig. Also das ist auch noch stabil,
dass die Null bei der 7 vor der Null bei
der 8 auf jeden Fall ist.
Das kommt auch noch dazu, das beantwortet die Frage jetzt nicht,
aber genau, das ist auch noch schön.
Das andere ist, bei dem Verfahren würdest du ja
nochmal komplett über das REC rübergehen
Und unter Umständen dauert das länger, als jetzt über
das ARR rüberzugehen. Das ist eine geringe Optimierung,
noch die man da haben kann, ob man die haben will,
weil man geht vorher ja schon über das RRC zweimal rüber,
aber der Hauptgrund ist der Erstgenannte, dass da noch mehr hinterhängt.
Okay. Sonst noch Fragen. Das erste,
man muss sich überlegen,
die beeinflussen sich jetzt
Ja. Warte kurz. Kannst du dir deine Fragen merken,
den kann ich immer direkt antworten? Also die erste Anmerkung war gerade,
man muss aufpassen, wie feinmarschig das ist, weil,
wenn da jetzt nicht nur zwei und drei vorkommt,
sondern sowas wie 2,5 oder so, dann ist das doof.
Aber mit 2,5 funktioniert das sowieso nicht,
weil du dann ja nicht auf das Array-Element zugreifen kannst.
Also da müsstest du noch irgendwie, was weiß ich,
wenn du weißt, es gibt immer Nachkommazahlen,
dann multiplizierst du am Anfang alles mit Zähnen,
dann tritt sowas nicht auf, sondern hast du schon 2,25 oder sowas.
Aber genau, also das Verfahren funktioniert auf jeden Fall nur,
wenn du irgendwie mit Zahlenwerten arbeiten kannst,
weil du die Zahlenwerte brauchst,
um direkt in das Array zuzugreifen,
sonst klappt das nicht
Ja. Das war im Prinzip eine große Anzahl von Platzen
, die alle... Jetzt muss ich später... Warte,
da ging es jetzt um die Effizienz,
dass man quasi, ich versuche es mal zusammenzufassen,
aber das ist quasi vom Verhältnis dieser Zahlen K und N,
also die K, gibt ja quasi den Zahlenbereich an,
in dem sich die N-Werte bewegen.
Das ist quasi vom Verhältnis dieser beiden Zahlen zueinander abhängt,
ob das jetzt effizient ist oder nicht. Genau,
ist richtig, wenn jetzt dieses Beispiel hatte ich vorhin,
also gut, eine Katastrophe ist, dass wenn ihr irgendwie sagt,
ich habe zwei Zahlenwerte, die will ich sortieren,
der eine ist eins und der andere ist 10.000. So,
da brauchen wir nicht das Verfahren machen.
Da würde ich mir am Anfang so ein Counting-Arry von 1
bis 10.000 machen für nix. Also da kann ich auch einmal
drauf gucken und die in die richtige Reihenfolge bringen und fertig.
Genau, also davon hängt es sehr entscheidend ab.
Und dritte. Unglaublich groß. Ja. Genau,
das war das Gleiche nochmal
Genau, da steht es auch nochmal,
wenn man hier jetzt so eine Laufzeitanalyse macht,
dann hat man hier so eine Schleife,
die ist OK, hier hat man noch eine,
die ist und OK und hier hat man zwei,
die sind in ON, ne?
Also habe ich zwei solche Schleifen und dann kann man eben
sagen, Countings heute ist stabil, das ist schön.
Also wenn ich zwei gleiche Werte habe,
bei denen der eine im Eingabe-Eri vor dem anderen kommt,
dann kommt der auch im Ausgabe-Eri vor dem anderen.
Ja, und dann kann man eben sagen,
dass das in O von N plus K liegt und dass es
eben unter Umständen gar nicht so toll, wenn K irgendwie unglücklich ist.
Aber in der Praxis wählt man das dann meistens mit K
irgendwie so in O von Ende ist.
Also wenn ich irgendwie tausend Werte sortieren will und ich weiß,
alle sind so zwischen 1 und 3000,
dann ist das ziemlich gut,
dann hat er
so eine Laufzeit von TäterInnen,
Ja, kam wieder mit Schleifen in Varianten gezeigt werden,
dass es vor allem für,
also bei denen hier von Zeile 1 bis 9,
da muss man nicht unbedingt mit Schleifenvarianten arbeiten,
das kann man auch so ganz gut argumentieren,
aber hier Zeile 10 bis 13,
da kann man vielleicht mal mit einer Schleifen in Variante arbeiten,
um irgendwie das Gekruddel hier, BCAJ,
um das ein bisschen aufzusplitten.
Genau, zur Übung oder im Kormen nachlesen.
Ja, was haben wir da noch? Genau,
da nochmal die Anmerkung, man findet da nirgendwo in dem
Code Vergleiche und das verwendet eben einfach die Werte,
um in das Arry zuzugreifen
Deswegen, weil wir nicht vergleichen, können wir eben diese Schleife,
diese Schranke durchbrechen, dass wir gesagt haben,
bei vergleichenden Sortierverfahren habe ich so eine Schranke, oh, Enmaluelle, Omega in Malogin.
Jochen, da gibt es noch zwei weitere Sortierverfahren,
das machen wir einmal ganz kurz hier, Reddick Sword,
da gehe ich davon aus, ich habe so diestellige Zahlen,
also irgendwie, weiß ich, fünfstellige Zahlen, das kommt,
glaube ich, noch aus der Zeit der Lochkarten, das Verfahren.
Und dann hat jede Stelle ka mögliche Werte,
das sieht schon wieder so ähnlich aus wie das,
was wir eben haben, dass ich für jede Stelle zum Beispiel weiß,
das ist, zahlen wir zwischen 0 und 9,
dann habe ich irgendwie eine Dezimalzahl mit D-Stellen oder so.
Und dann kann ich die Zahlenstelle für Stelle beginnen mit
der niederwärtigsten,
durch ein stabiles Sortierverfahren sortieren
Und dann habe ich die Zahlen insgesamt sortiert. Das wäre
Reddick Sword und bei Bucket Sword gehe ich von der gleichverteilten
Eingabe aus und teile das Intervallen in gleich große Buckets.
Und dann verteidige ich die Eingabewerte auf die Buckets. Dann muss man da irgendwie,
wenn ich hier mit gleichverteilter Eingabe und so, das sieht schon so aus,
als ob man das nicht mehr mit den Techniken analysieren kann,
die wir bisher so hatten.
Da muss man irgendwie anders rangehen. Das beides nur,
damit ihr nochmal sehen könnt, dass man, wenn ich andere Eingaben habe,
bei Reddick Sword kriege ich ja auch irgendwie Zahlen,
aber jetzt nutze ich irgendwie wieder was anderes aus.
Bei dem Counting Sword von dem habe ich eben ausgenutzt,
dass ich auf mit Zahlen arbeiten kann, sodass ich die als Arry-Element-Zugriff benutzen kann.
Hier will ich jetzt ausnutzen, dass ich irgendwie immer weiß,
alle Zahlen sind vierstellig oder so und dann kann ich das irgendwie erst nach dem ersten,
dann nach dem zweiten, nach dem dritten, nach dem vierten Stelle sortieren.
Und bei Bucket Sword sagt man eben, hey,
ich gehe davon aus, dass meine Eingabe gleich verteilt ist,
dass die Zahlen irgendwie alle ähnlich oft vorkommen.
Ja, aber die nur Sozialanmerkung. Die hatten wir,
vergleichendes Sortieren oben und mit dieser schicken unteren Schranke und halt
die nicht vergleichen und vor allem eben dieses Counting Sword,
die anderen beiden nur so, dass man mal sehen kann,
wie man da noch umspielen kann.
Und jetzt kann man eben die Frage stellen, ob es
auch untere Schranken für andere Verfahren gibt. Also wenn wir jetzt,
wir hatten bisher uns ja ordentlich an dem Sortieren abgearbeitet,
aber wir haben ja letztes Mal auch irgendwie Grafen gesehen und
auf Grafen kennt ihr ja schon den einen oder anderen Algorithmus,
irgendwie so kürzeste Pfade bestimmen oder irgendwie sowas.
Flüsse, Spannbäume, was man da alles so machen kann
oder eben auch, ne, beliebige andere Verfahren.
Und dann ist immer die Frage, ne, kann ich
eine untere Schranke eingeben? Also interessiert mich ja immer,
weil, ne, ich kriege eine Problemstellung,
ich entwerfe einen Algorithmus und normalerweise würde ich jetzt halt überlegen,
kann ich es noch schneller machen.
Und entweder würde ich jetzt meine Zeit da reinstecken,
schnelleren Algorithmus zu finden oder wenn mir irgendwie nichts einfällt,
dann möchte ich meine Zeit da reinstecken,
eine untere Schranke zu finden, dass ich dann irgendwie sagen kann,
okay, Es geht gar nicht schneller, ja.
Ja, ich würde sagen, da muss ich alles einmal...
Ja, naja, hier haben wir ja sogar gezeigt, Amber Login.
Oder was meinst du jetzt? Ja, wofür? Für
alle Verfahren? Ja, alles Verfahren. Wenn mein Problem ist,
gegeben ein Array, ich möchte das erste Element des Arrays zurückliefern.
Da muss ich mir nicht alles angucken. Glücklicherweise,
ich meine, das ist ein blödes Problem,
aber unter Umständen, es gibt auch Verfahren,
die schneller sind als auch von denen.
Binäre Suche im sortierten Array. Ich glaube,
wir reden gerade aneinander vorbei
Ich meine, ganz allgemein, ich möchte eine Möglichkeit,
ich will eine Technik haben, sowas wie Induktion,
Widerspruchsbeweis, irgendwas, ich will eine Technik haben,
mit der ich untere Schranken für Probleme angeben kann,
dass ich weiß, gegeben dieses Problem,
es gibt keine Möglichkeit,
schneller zu lösen als so und so.
Ja. Auftritt, Komplexitätstheorie
P-N-P-N-P-Vollständigkeit. Wer kennt das noch aus FG1?
Wer hat es schon wieder verdrängt? War die Frage,
alles wer hat es schon wieder verdrängt?
Ich bin noch dabei oder was hast du gesagt?
Ich verdränge es immer noch. Ja, das kann man
jetzt schön benutzen. Wer hat das noch nicht gehabt?
Wer hat MP-Vorständigkeit noch nicht gehabt? Echt nicht,
was studierst du? Die anderen trauen sich noch nicht.
Was studierst du? Ich habe Wirtschaftsinformatik. Ah,
okay.
P-N-P-N-P-Vorständigkeit brauchen wir
Idee kommt gleich, kurze organisatorische Einschub vorher.
Wir haben wieder einen Raumwechsel, die Gruppe 19 diese Woche,
Freitag 12 bis 14 Uhr, F334, die ist in D129.
Nur diese Woche ist jemand da von der Gruppe?
Einer, wirklich jetzt. Echt jetzt? Zwei, zwei.
Hat er dich gerade gefragt, so sind wir da echt?
Ist das unsere Gruppe? Also, in D129,
Grund ist Disputation in F334. Und da so eine Disputation ja
immer ein großes Ereignis ist, kann man dafür gerne mal
den Raum räumen
Ups. Und das Zweite ist,
ich hatte das ja schon mal vor einer Woche oder vor zwei angekündigt,
dass die neue Professorin für Computer Science Education, die Maria Knobelsdorf,
dass sie so eine Studie machen möchte über das Arbeitsverhältnis,
Arbeitsverhalten von Studierenden,
wie geht ihr so an solche Theorieaufgaben ran und so.
Und das wollen wir dann jetzt in dieser oder der nächsten Woche
eben machen. Und soll ich da noch was zu sagen
oder willst du? Soll ich? Okay. Genau,
da kommt jetzt diese Woche dann eine Masterstudentin in die Übungsgruppen bei euch
und stellt das noch einmal kurz fünf Minuten ein bisschen genauer vor.
Und wer Lust hat, mitzumachen, der kann sich dort eben auf den Zettel eintragen.
Und dann ist die Idee quasi, dass sie zu euch kommt,
wenn ihr irgendwie in eurer Kleingruppe an den Aufgaben arbeitet und euch beobachtet und interviewt und sowas.
Und das Ziel ist eben, dass wir,
wenn sie dann nach der Arbeit zu uns kommt und sagt,
ja, das läuft alles super, die brauchen keine Hilfe,
dann sage ich sich, alles klar,
wir können das weiter so machen mit der Lehre.
Und wenn sie zu uns kommt und sagt,
du Frank, das geht überhaupt nicht,
da ist ein Whiteboard und ein Stift und dann stehen die Studis da und sagen,
kenne ich nicht, Stift, weiß ich nicht,
kann ich nicht mit umgehen.
So, dann wissen wir, okay, da müssen wir ansetzen.
Okay, die eigentliche Idee ist natürlich,
wir wollen gucken, wie geht ja eine Theorieaufgabe ran,
irgendwie guckt er erst die Definition nach oder geht ihr brutal drauf los?
Googelt ihr erst oder was macht ihr so?
Und damit wollen wir halt ein bisschen arbeiten,
dass wir damit dann hoffentlich verbessern können, wie wir irgendwie diesen Theorieunterricht didaktisch aufbauen.
Deswegen auch sind alle dazu aufgefordert, mitzuarbeiten,
also sowohl die Gruppen, die jetzt sagen, irgendwie,
AD finde ich easy going, als auch die Gruppen,
die sagen, boah, AD ist echt so ein Brocken,
das ist echt schwer,
dass wir da eben irgendwie so eine gute Mischung reinkriegen.
Ja, ich weiß gar nicht, wie viele Gruppen willst
du haben? Zehn, so ja. So zehn,
zwei bis drei Leute Gruppen wären cool,
das sollten wir
eigentlich hinkriegen
Ja, überlegt euch schon mal, ob ihr Lust habt mitzuarbeiten,
so ab heute gehst du dann da rum in die Übungsgruppen,
heute morgen, übermorgen und dann kann sie da echt noch ein bisschen mehr zu erzählen.
So, das dazu. Genau,
und der aktuelle Übungszettel, also der vierte,
der bietet sich dazu eben an,
weil es jetzt bei dem vierten Aufgabenzettel wird es eben um dieses P,
NP, NP vollständig gehen und so,
also wieder um ein deutlich theoretischeres Thema als jetzt einige andere Themen in der Vorlesung hier.
Und da kommt das dann eben ganz cool dann beobachten.
Ja, zurück in die Vorlesung oder Fragen dazu kurz?
Fragen dazu? Ja, gut
So, dann gehen wir da mal rein in dieses PNPM wie vollständig und so.
Also alle bisher behandelten Probleme haben eins gemeinsam,
nämlich die Algorithmen waren in Uf von N hochkahr,
also irgendwie in Polymialzeit. Auch sowas wie ON mal Login,
kann ich ja weiter nach oben abschätzen durch ON-Quadrat,
also ist das auch irgendwie polymiell beschränkt.
Wenn wir jetzt später in der Vorlesung einen anderen Stoff machen,
so eine Grafenalgorithmen und so weiter, da wird uns auch ständig begegnen,
dass die Algorithmen in Polymialzeit möglich sind.
Das aber geht halt sehr wahrscheinlich nicht immer an,
die die FG1 hatten, kennen da schon hier aussagenlogische Formeln und solche Geschichten,
scheinbar nicht immer, aber wir haben ein Problem damit,
untere Schranken zu zeigen.
Bei dem Countings, bei dem Sortieren, was wir eben gemacht haben,
vergleichende Sortierverfahren, da ist uns das gelungen.
Da haben wir irgendwie drauf geguckt, haben gesagt,
so ja, womit kann man da arbeiten?
Da hat man irgendwie mit der Anzahl der Vergleiche gearbeitet und konnte irgendwas machen.
Jetzt schon? Ich habe noch gar nicht angefangen. Ja,
geht ja noch, faule Äpfel oder so wären nicht schlimmer gewesen.
Allgemein ist es aber so, also was ist das Problem?
Wenn ich euch ein Problem gebe und sage,
entwerft meinen Algorithmus dafür, dann entwerft ihr einen Algorithmus und könnt sagen,
hier guckt mal, der hat die und die Laufzeit ist super.
Also eine obere Schranke für ein Problem zu finden und die zu zu verbessern,
dass es quasi deswegen nicht so problematisch, weil ihr immer,
ihr entwickelt einen Algorithmus, ihr macht eine Laufzeitanalyse,
ihr sagt, hey, ich löse das Problem in ein UN-Quadrat.
Dann kommt der nächste, stellt einen anderen Algorithmus vor,
macht eine Laufzeitanalyse, sagt, meiner schneller, der ist in U von N.
Das ist immer eine Sache, die er da macht,
ein Algorithmus entwerfen. Bei unteren Schranken,
so wie auch bei den Sortierverfahren, muss man irgendwie eine Möglichkeit haben,
um über alle Algorithmen, die das Problem theoretisch lösen, zu argumentieren.
Und der Ansatz bei diesen Entscheidungsbäumen war eben,
dass man gesagt hat, wenn ich ein vergleichendes Sortierverfahren habe,
dann sind da ja solche Vergleiche drin.
Und wie viele muss ich machen, um zu allen Permutationen
zu kommen
Das war völlig unabhängig davon, was es noch alles für Sortierverfahren gibt.
Wir haben das zwar jetzt irgendwie mit Insearch and Sword und Merchthod oder so so ein bisschen illustriert,
dass da so Vergleiche drin sind,
aber es gibt ja noch zig weitere Sortierverfahren,
die mit Vergleichsoperationen arbeiten, aber die sind alle damit abgedeckt.
Und solche Ideen zu finden ist eben allgemein eben sehr, sehr schwierig. Man muss quasi,
man argumentiert nicht darüber, dass ich einen Algorithmus habe,
der das Problem löst und ich argumentiere darüber, dass alle Algorithmen,
die dieses Problem lösen und ich kenne gar nicht alle,
dass die bestimmte Eigenschaften haben.
Das ist schwierig. Deswegen steht hier auch,
dass es bisher sehr beschränkt möglich.
Also eigentlich können wir da kaum was
Ein Beispiel, das ihr kennt,
Bestimmung der kürzten Pfade im Grafen, irgendwie ein UV-Quadrat,
wer das jetzt nicht kennt, nicht so schlimm,
gegeben Grafen und zwei Knoten,
S- und Tee und ihr wollt irgendwie eine möglichst kurze Verbindung vom Startknoten
zum Zielknoten haben und das Verfahren kann man eben in O von V-Quadrat geht sogar noch ein bisschen schneller,
aber in O von V-Kadrat kann man das machen.
Und ja, schön ist so, ne. Aber wenn
ihr den längsten Pfad bestimmen wollt, gleiches Problem gegeben,
der Graf und zwei Knoten, S- und T,
und ihr wollt nicht den kürzen Pfad bestimmen,
sondern ihr wollt den längsten Pfad bestimmen.
Das Problem scheint irgendwie komplizierter zu sein.
Und da kann man sich jetzt hinsetzen und kann sagen,
ich nehme einfach immer die teuerste Kante oder so,
das wird aber nicht,
das wird unter Umständen nicht umzwingend
der längste Pfad
Da gibt es bisher noch keinen Algorithmus,
der das irgendwie für so einen ON-Hochkaf für irgendeinen Karl löst,
also auch so O von N hoch 5 oder irgendwie sowas
geht nicht oder wovon er noch 1000 oder so.
Hat man halt noch nichts gefunden. Und hier seht ihr schon,
kürzester Pfad, längster Pfad, das klingt irgendwie sehr ähnlich.
Trotzdem kann man sagen, dass hier so ein P,
ein Polonialzeit lösbar, also ein OV-Quadrat und das hier scheinbar irgendwie nicht.
Da steht da auch nochmal jetzt zur Nachbereitung,
dass es ganz viele ähnlich klingende Probleme gibt,
die man lösen kann oder eben nicht schnell blühen kann
Was man gerne hätte, ist,
für dieses längste Pfadproblem möchte ich gerne zeigen können,
dass das für alle K in Omega von NOK ist.
Dann weiß ich quasi, es gibt keinen N-Hochkas,
sodass ich das in NOK 4 Schritten lösen kann,
weil es ja immer noch schlimmer geht.
Oder ich will alternativ zeigen, dass Longus Parts
nicht in O von NOK für alle K ist.
Aber da seht ihr auch schon anders als eben,
wenn ich hier zeigen will, das kürzeste Pfade in O von V-Quadrat ist,
dann reicht es ein Algorithmus anzugeben, sodass es da drin ist.
Hier muss ich irgendwie mit diesen alle Aktionen arbeiten.
Ich muss ja zeigen, dass das für alle K gilt,
für alle K, kriegen wir irgendwie nicht hin.
Warum will man das machen können? Wie gesagt,
gegeben ein Problem, möchtet ihr euch sicher sein können,
dass der Algorithmus, den ihr gerade gemacht habt,
dass der wirklich der schnellste ist.
Oder andersherum, Ihr möchtet nicht unnötig viel Zeit in das entwickeln,
eines schnellen Algorithmuses stecken, wenn es wahrscheinlich gar keinen gibt.
Also beispielsweise sich jetzt irgendwie drei Wochen damit zu beschäftigen,
einen Algorithmus zu finden, der längste Pfade schnell löst,
dass es ziemlich verschenkte Zeit so, ne?
Also da muss man schon irgendwie Experte auf dem Gebiet von NP Vollständigkeit sein oder so,
weil das wäre, also dafür einen schnellen Algorithmus zu finden würde,
so dieses lange stehende PNP-Problem lösen.
Und ich glaube nicht, dass man das einfach so mit
so einer Algorithmenbrille mal eben in zwei Wochen hinkriegt,
deswegen ist das eher so verschenkte Zeit.
Ja, also zusammengefasst, wir haben Probleme,
unsere Schranken zu zeigen
Aber gleichzeitig kennen wir viele Probleme,
für die wir keine effizienten Algorithmen haben,
also keine Algorithmen, die ein Pullimialzeit das Problem lösen.
Ziel. Wie kann man jetzt, wenn ich,
ich nehme jetzt quasi ein Problem und ich schaffe es nicht,
einen effizienten Algorithmus zu implementieren.
Jetzt ist irgendwie ja meine These, wahrscheinlich geht das gar nicht.
Und mein Ziel ist es jetzt, diese Annahme möglichst gut
zu untermauern. Was ich irgendwie sagen kann, naja,
wenn das ginge, dann passiert das und das.
Und wenn das halt sehr, sehr unwahrscheinlich ist,
dass das passiert,
dann kann ich mir sicher sein,
dass das vielleicht doch nicht geht
NP-Vollständigkeit. Damit wird jetzt hier diese Kompliziertheit eines Problems formalisiert.
Die Idee ist, dass wir sagen können,
wenn ein Problem NP vollständig ist,
dann ist es zumindest sehr, sehr, sehr,
sehr unwahrscheinlich, dass ich das schnell lösen kann.
Da wollen wir hin. Genau,
da steht es auch nochmal zur Nachbereitung
Genau, deswegen wollen wir heute und morgen,
heute und nächste Woche das hier noch machen.
Wir wollen formal fassen, was ein Problem ist und was
eine Kodierung dieses Problems ist und dann wollen wir P und
NP einführen und eben die Sinnhaftigkeit dieser Definition ein bisschen erläutern.
Das ist das, was wir heute noch machen wollen und
nächstes Mal wollen wir dann Reduktionen einführen und damit NPV Vollständigkeit
einführen und dann eben einige Probleme als NPV nicht nachweisen.
Also dieser ganze Themenblock NP Vollständigkeit,
den machen wir nächstes Mal in den zwei Stunden und heute
befassen wir uns noch mit den ersten zwei Punkten
da P und NP einzuführen
Also, erst mal, was ist überhaupt ein Problem so?
Die Begründung, warum man das jetzt macht,
ist, wenn man das jetzt formal fassen möchte,
man will ja so ähnlich wie mit diesen Entscheidungsbäumen,
wenn man jetzt irgendwie das Ganze formal ein bisschen handhabbar machen.
Und wenn ich sagen können will, es gibt für dieses Problem
beispielsweise längsten Pfad zu finden, keine schnelle Lösung,
dann ist der erste Schritt überhaupt erst mal konkreter zu fassen,
was das Problem ist.
Also, wie ich das Problem formal gut ausdrücken kann.
Ziel ist, irgendwie sowas zu haben,
wie dass sie dann sagt, naja, jedes Tupel,
GST, Graf,
Startknoten,
Zielknoten ist eine Instanz des Problems
Das ist genau dann eine Ja-Instanz oder sowas,
wenn eben der Pfad eine bestimmte Länge hat oder irgendwie so oder GSTK,
bekam noch der Schranke, dass sie dann sagen kann,
das ist eine positive Instanz,
wenn der längste Pfad von S zu T mindestens die Länge K hat und sonst ist eine Negativinstanz.
Sowas will ich haben können. Also quasi führt man dieses Lösen des Problems
zurück auf Entscheidungsprobleme, dass nur nur noch Ja oder Nein sagen muss. Anderes Beispiel addieren,
statt gegeben zwei Zahlen und als Ergebnis die Summe herauszugeben,
würde man jetzt drei Zahlen kriegen, A, B,
C, also ein Tupel, A, B,
C und müsste jetzt entscheiden, ist C tatsächlich die Summe A plus B oder nicht.
Dann habe ich Tupel, die okay sind, zwei,
fünf, sieben ist ein Tupel, das okay ist,
weil es 2 plus 5, sieben ist,
2,5,8 ist ein Tupel,
das nicht okay ist,
weil 2 plus 5 eben nicht acht ist
Darauf will man das gleich zurückführen. Und da braucht man eben noch Probleme,
also dafür muss man diesen Begriff des Problems konkreter fassen.
Und weil wir ja mit Maschinen und Algorithmen und so arbeiten,
auch nochmal ganz konkret diesen Begriff der Kodierung.
Aber das ist beides so ein bisschen,
also wenn euch das eben schon klar geworden ist,
dann ist das beides ein bisschen, ja, kann man machen.
Ist vor allem deswegen drin, weil das im Kormen
sehr ausführlich so gemacht wird. Und wenn ihr das in
dem Kapitel lest, dann sollt euch das nicht verwirren.
Also was macht man, man nimmt so eine Menge von Probleminstanzen ihm?
Das sind ja jetzt eben dann irgendwie dieser Graf und irgendwie Stat und Zielknoten.
Und man nimmt eine Menge S von Problemlösungen.
Und ein abstraktes Problem, Kuh ist dann eben
diese Teilmenge aus I-Kreuz
Also immer Probleminstanz mit der zugehörigen Lösung. Wenn man jetzt
dieses kürzeste Pfadproblem hat oder auch das längste Fahrtproblem,
dann könnte die Menge à la Tupel GS oder Menge I
sind an all diese Tupel GST, Graf, Startknoten,
Zielknoten und die Menge S ist dann eben eine Folge von Knoten hier,
also von SV 0V1 bis irgendwie zu Teener.
Dann weiß ich, das ist der Pfad von S zu Tee.
Dann habe ich die Probleme in Steins GST und die Lösung.
Beides in Tupel getan und das ist ein Element von Kuh.
Das, worum es sonst vor allem geht, ist,
dass man eben so ein Problem nachher ausdrücken kann
als so ein Tupel immer
Oder dass man eine Probleminstanz als Tupel ausdrücken kann und das Problem selbst
dann als die Menge aller Tupel, die ja Instanzen sind.
Da wollen wir nachher hin. Dann brauchen wir noch einmal
kurz Kodierung, weil irgendwie hier mit GST zu arbeiten,
jetzt muss man sich einmal überlegen, wie kodiere ich das?
Bei Grafen hatten wir ja diese Idee irgendwie,
dass wir gesagt haben, naja, Artiazenzlisten hat ja Azenzmatritzen und sowas.
Das versucht man jetzt formal auch ein bisschen allgemeiner zu fassen,
dass man eben sagt,
die Eingabe des Algorithmus ist ja eigentlich nicht das Tupel GST,
sondern das Tupel GST irgendwie geeignet kodiert.
Sprich, die Länge der Eingabe ist noch wichtig und
das machen wir jetzt auch so ein bisschen
Ein bisschen direkt, dass wir einfach sagen, Zahlen kodieren wirbinär und Buchstaben
kann man ja auch irgendwie im Asky-Code oder sowas binär kodieren.
Und dann hat man das eigentlich schon. Das Wichtige ist,
also was für uns eigentlich nicht wichtig ist, ist,
wie die Kodion genau geschieht, sondern nur,
dass sie geschieht und dass die Kodierung immer nicht die Eingabe zu doll aufbläht.
Also wenn ich als Eingabe irgendwie zwei Zahlen kriege und mit
denen irgendwas machen soll und ich kodiere die Eingabe unnäher,
also die Zahl 5 wird durch fünf Striche kodiert,
dann habe ich halt ein Problem,
weil dann lässt sich nicht mehr so gut mit Pudeln im Jahrzeit arbeiten und sowas,
weil dann die Eingabelänge schon extrem aufgebläht wird.
Also dann brauche ich für die Zahl 1000,
brauche ich dann eben auch die Eingabelänge 1000 und das ist doof,
das verfälscht alle Aussagen nachher
Das ist eigentlich so die Kernaussage, die wir hier machen,
dass wir irgendwie immer mit so einer sinnvollen Binärkodierung arbeiten.
Und damit klappt eigentlich auch alles.
Also ihr könnt dann den Grafen einfach so kodieren,
dass ihr eine Folge habt von Knoten, V0V1, V2,
V3 oder so und den Indie-C halt immer Binär kodiert,
dann passiert da nichts Schlimmes.
Nur hier da eine Unähe und monatisch sollte sie eben nicht
sein, also Unähe. Genau. Und hier nochmal,
die meisten Kodierungen sind pulinial verwandt
Deswegen auch nur, wir wollen nachher dahin kommen,
dass wir sagen können, Algorithm, ein Problem ist effizient lösbar,
wenn es ein Polemialzeitalgorithmus gibt, der das löst.
Dann ist das mit der Kodierung wieder egal, wenn die
sich sowieso alle im Polemialzeitalgorithmus ineinander umwandeln lassen. Also für die Untersuchungen,
die wir vorher hatten, dass wir irgendwie sagen wollten,
dieses Problem will ich jetzt nicht nur in UN-Quadrat lösen,
sondern in UN oder sowas, dafür ist das alles wichtig.
Aber für das jetzt hier,
wenn man einfach nur sagen will, es gibt einen Polynom,
der das Problem löst, es gibt einen Algorithmus,
der das Problem im Problemalzeit löst und das genaue Polynom ist mir gar nicht wichtig,
dann ist das mit der Kodierung halt egal.
Nur, dass man im Hinterkopf hat,
es gibt irgendwie eine sinnvolle Kodierung davon. Ja,
jetzt kann man noch sich über konkretes Problem,
kann man jetzt noch definieren, dass man sagt,
die Instanzenmenge soll jetzt die Menge der Binieren String sein
Sprich, jedes Problem, GST kodiere ich jetzt irgendwie durch ein Beanie and String.
Da kriegt man auch hin, dann nennt man das ein konkretes Problem.
Und was wir jetzt primär machen, ist,
dass wir sagen, statt diesem Tupel GST kann man,
wenn man das besonders betonen will, macht man jetzt auch nicht immer,
wenn man das besonders betonen will,
macht man noch solche eckigen Klammern drumherum, um zu sagen,
die Eingabe des Algorithmus ist eben das Tupel GST auf sinnvolle Weise kodiert.
Und auf sinnvolle Weise kodiert heißt dann eben,
dass ich so wie wir das in den ersten ein,
zwei Vorlesungen betont haben,
dass wir dann immer irgendwelche Kennzahlen haben bezüglich deren Mann.
Die Laufzeit des Algorithmus ist gut ausdrücken kann.
Also beim Grafalgorithmus, die Anzahl der Knoten oder irgendwie sowas
Jo, so, jetzt kommt das mit Optimierungsentscheidungsproblems.
Das war jetzt so für Coudierung und Probleme. Das ist auch
nicht ganz so wild so. Das geht mir darum,
dass ihr euch nochmal bewusst macht, okay,
ich habe irgendwie eine Problemstellung und ich muss die irgendwie geeignet codieren.
Was jetzt wichtiger ist, ist, viele Probleme sind ja so Optimierungsprobleme.
Sowas wie Kürze ist ein Pfad für einen längsten Pfad finden.
Was steht da noch so maximaler Fluss oder so?
Was aber einfacher ist nachher,
deswegen hatte ich es auch schon gesagt hier mit irgendwie,
dass man nur wissen will, ist das Tupel drin oder nicht?
Ja oder nein? Das ist ein Entscheidungsproblem.
Da kriege ich eine Eingabe und sage entweder ja,
die ist gut oder nein,
die ist schlecht
So, und darauf will man eigentlich die Theorie einschränken.
Und jetzt kann man, ja, da steht jetzt im Allgemeinen,
es ist jedoch leichter ein Optimierungsproblem, in ein Entscheidungsproblem umzuwandeln,
das nicht schwieriger ist, wobei schwieriger hier immer bedeutet,
bezüglich Polymialzeit.
Also wenn ich Polymial viel mehr Aufwand habe,
ist das okay. Und das sehen wir gleich nochmal,
warum das tatsächlich leichter ist, warum das das Gleiche ist.
Statt also gibt es einen kürzesten Pfad von S nach Tee
und was ist sein Wert? Das wäre ja die Optimierungsfrage
. Ich kriege nur den Graphen und die Zahlen,
die Knoten S&T, fragen wir jetzt eben,
gibt es so einen Pfad mit Kosten kleiner gleich K?
Also das K wird auch noch mitgeliefert
Jetzt kann man sich eben überlegen, dass man,
wenn man das Entscheidungsproblem lösen kann, auch das Optimierungsproblem lösen
kann und andersrum und sich der zusätzliche Aufwand in Grenzen hält.
Idee? Warum ist das Äquivalent? Also ihr müsstet quasi,
um zu zeigen, dass das Äquivalent ist,
dürftet ihr immer davon ausgehen, dass ihr einen Algorithmus habt,
der jetzt wahlweise das Entscheidungsproblem oder das Optimierungsproblem löst.
Und dass ihr jetzt mit nicht zu viel mehr Aufwand das jeweils andere damit lösen könnt.
Also wenn ihr zum Beispiel das Optimierungsproblem oben lösen könnt,
Wie kann man jetzt ganz schnell das Entscheidungsproblem lösen?
Das ist noch einfach. Genau, das ist noch einfach,
ne? Also da sage ich irgendwie hier, ich kriege meine Eingabe GSTK beim Entscheidungsproblem,
jetzt nehme ich einfach das GST, wirft das in meinen Optimierungsalgorithmus,
kriege den Wert K raus oder so oder den kürzesten Pfad
und berechne einmal kurz das K. Und dann kann ich ja gucken,
hat der jetzt Kosten, kleiner gleich K oder nicht.
Und wenn der kürzeste Pfad halt teurer ist,
dann ist die Antwort zu dem Entscheidungsproblem nein und wenn der kürzeste Pfad,
dem wird K oder günstiger hat, bin ich fertig.
Das ist noch irgendwie gut. Andersrum,
wenn ich jetzt das Entscheidungsproblem lösen kann,
Und ich will jetzt aber da, wenn ich das Entscheidungsproblem lösen kann,
ich will jetzt aber das Optimierungsproblem lösen.
Wie mache ich das denn? Dass man es kaufen muss. Ja,
wo das nächst kleinere Karte nicht mehr integrieren kann, was nichts größer wird. Ja,
die Idee war jetzt quasi, die ganzen K-Better durchzugehen,
also mit einem kleinen K anzufangen und dann immer eins drauf zu addieren,
effizienter, also ginge, effizienter, mit.
Denk mal ans binäre Suchen. Naja,
das muss vielleicht einmal einen Tag auch von dem
weiter funktionieren
Genau. Das geht ein bisschen schneller, dass du halt,
guckst du mal nach. Also die Idee war jetzt quasi,
ich fange mit einem so einem K an und
dann halbiere ich das und dann gucke ich immer,
wenn das jetzt immer noch klappt, dann kann ich es weiter halbieren.
Und wenn es nicht mehr klappt,
dann springe ich halt in die Mitte von den beiden so.
Und ich weiß ja schon, am Anfang teste ich vielleicht
einfach mit Karl so viele Knoten, wie es gibt. So,
da weiß ich, dann weiß ich gleich, entweder gibt,
vielleicht gibt es ja auch gar keinen Fahrt von SCT,
aber wenn ich als K die Anzahl der Knoten gebe,
weiß ich auf jeden Fall, es gibt mindestens ein Fahrt.
Und danach teste ich das mit K-Hals und mit Knotenanzahl halbe.
Und dann, wenn er mir sagt, so ja,
es gibt einen Vater, der kürzer ist als das,
dann kann ich eben das nochmal halbieren oder sonst springe ich
eben auf drei Viertel oder so.
Dann habe ich das gemacht mit lugorithmisch von K
viel mehr Aufwand quasi.
Das ist okay
So, und jetzt noch Puliniumialzeit definieren,
wenn ich jetzt so ein konkretes Problem Kuh habe,
und ich habe eine Probleminstanz I, dieser Länge N,
dann sagen wir eben, dass ein Algorithmus in,
oder wenn ein Algorithmus in dieser Zeit,
O von TN, T ist jetzt irgendwie seine Laufzeitschranke,
wenn der jetzt eine Lösung produziert,
also formal so ein S, so das ISMQ ist,
dann sagen wir, dass er das Problem löst.
Also es ist jetzt sehr kompliziert formuliert für die Aussage gegebene Probleminstanz,
wenn der Algorithmus eine Lösung berechnet,
dann löst er das Problem so.
Okay, kann man so nehmen. Und wenn dieses T von N,
wenn das eben ein Polynom ist,
dann sagen wir,
dass er das in Polynialzeit löst
Wenn er so eine Laufzeit hier hat, oh, von N hoch
Karf für so eine konstante K, dann löst er
das impolemialer Zeit. Und die Menge all dieser Entscheidungsprobleme,
die impolemialer Zeit lösbar sind, die bilden jetzt diese Komplexitätsklasse P.
Und deswegen auch dieser ganze Kram mit Kodierungen und sowas,
damit man jetzt eben sagen kann, ich habe eine Klasse,
da sind Mengen drin.
Und jede Menge ist quasi ein Problem. Und jede Menge ist ein Problem,
ist das jetzt so ein bisschen irreführend,
weil die Menge ist quasi ja nicht für sich genommen das Problem,
sondern die Menge, das sind ja gerade Nudialinstanzen.
Aber da weiß man ja auch,
was die Nein-instanzen sind, nämlich alles andere.
Also charakterisiert diese Menge
quasi das Problem
Ja, so, jetzt wird das hier üblicherweise,
da sagt man jetzt üblicherweise, dass das effizient lösbar ist,
kann man sich nur überlegen, warum, wenn man sonne Laufzeitschranke hat hier,
dann ist das ja eher ineffizient, NO50 wird schon ziemlich schnell,
das wird schon bei Eingabe 2 irgendwie hässlich,
bei 3 noch hässlicher so, aber sowas tritt eben kaum auf,
so üblicherweise hat man das so,
dass wenn man irgendwann mal so einen Algorithmus findet,
der ein Problem in N hoch 10 löst oder so,
dann kann man die Schranke meistens relativ schnell drücken,
drücken,
Einziges Ding, wo das, glaube ich,
bisher noch nicht so ganz geklappt hat, ist diese,
dieses Problem, ob eine Zahl eine Primzeit ist oder so.
Da gab es ja mal diesen Durchbruch,
dass man endlich mal einen P-Algorithmus gefunden hat und der war dann irgendwie,
ich weiß nicht mehr genau, in N hoch 8 oder irgendwie sowas.
Und das hat man zwar auch gedrückt gekriegt, aber bei Vibe
noch nicht dahin, wo die richtig schnellen randomisierten Verfahren sind.
Also wenn man irgendwie Primzahlentests machen will,
machen wir das eigentlich immer noch mit randomisierten Verfahren,
obwohl man mittlerweile auch ein deterministisches Polyumialzeitverfahren hat.
Aber da hat man es quasi noch nicht hingekriegt,
diesen Exponenten hier so zu drücken,
dass man sagen würde,
das ist jetzt cool
Der ist zwar besser geworden als bei der ursprünglichen Publikation,
auch deutlich besser als bei der ursprünglichen Publikation,
aber immer noch so, dass reanomisierte Verfahren deutlich schneller sind.
Also wer sich für sowas interessiert, vielleicht aus der Krypto-Ecke
oder Zahlentheorie-Ecke oder so, da wird immer noch rumgewuselt.
Ja, warum ist das immer noch sinnvoll, das hier zu machen?
Weil sich die ganzen Rechnermodelle mit polemiellem Mehraufwand simulieren.
Also auch sowas wie irgendwie parallele Modelle und all sowas.
Das liest sich als ein polemie Mehraufwand, das ist alles schön.
Dann kommt dazu, ein Polynom lässt sich gut rechnen
Und als letztes, es hat sich einfach bewährt.
Also sowohl in der Theorie als auch in der Praxis hat sich das bewährt,
dass man sagt, wenn man es im P lösbar ist,
es ist effizient lösbar, wenn man es nicht im P mehr lösbar ist,
ist es nicht mehr effizient lösbar.
Unser Problem ist jetzt aber, dass wir es nicht gut hinkriegen,
von einem Problem zu zeigen, dass es nicht im P liegt.
Das möchten wir ja gerne machen können. Wenn wir sagen,
alles, was im P ist,
von dem sagen wir, dass es effizient lösbar ist,
dann möchten wir jetzt sagen oder zeigen können,
dieses Problem ist nicht in P, um deinen Schluss folgen zu können,
okay, dann ist es auch nicht effizient lösbar.
Und das kriegen wir aber nicht gut hin.
Da nochmal zur Nachbereitung, Sinnhaftigkeit der Definition,
kann man hinterfragen, ist aber aktuell so die Beste,
mit der man
richtig gut arbeiten kann
Gibt auch schon so Ansätze, dass man eine andere Klasse nehmen will,
als die Probleme, die sich effizient lösbar effizient lösen lassen.
Nämlich so Klassen, die was zu tun haben mit Radomisierung noch.
Also quasi randomisierte Algorithmen, die im Polymialzeit laufen.
Das wird ein bisschen größer. Ja, so,
bevor wir da jetzt ganz tief einsteigen,
gucken wir uns nochmal an, diese Theorie der formalen Sprachen.
Das ist nämlich schön, dass wir die jetzt benutzen können,
wenn wir mit Entscheidungsproblemen arbeiten. Dann kann man nämlich einzelne
Probleme gut miteinander kombinieren und da mal einmal kurz der Refresher,
wer jetzt FD1 gehabt hat, kennt das alles schon.
Also wenn wir so ein Alphabet haben, Sigma,
das ist eine endliche Menge von Symbolen.
Meistens nehmen wir 0 und 1,
Binjakodierte Swings
Dann nehmen wir eben Sigmar Stern für die Menge aller Worte,
die aus Elementen aus Sigmar gebildet werden.
Also Epstilon hier für das leere Wort, dann die einelementigen Wörter,
0 und 1, dann die Wörter mit zwei Buchstaben,
0,0, 1, 1, 0, 1,
1, dann die mit rein und immer so weiter.
Wichtig ist, die Menge aller Worte,
die aus Elementen aus Sigmar gebildet werden können und die endlich sind.
Also da steht jetzt nicht drin, 0,0, 0 und
unendlich viele Nullen, sondern jedes Wort da drin ist endlich.
Sigmar Stern selbst ist eine unendliche Menge, aber jedes Wort da drin ist endlich.
Dann nennen wir jede Teilmenge von Sigmar Stern eine Sprache und
einige davon sind ja auch gleichzeitig Probleme.
Also wenn wir gesagt haben, Probleme,
ich kodiere diesen Grafen GST irgendwie als Binärstring,
dann sind all diese auf eine sinnvolle Art und Weise binierten Grafen mit bestimmten Eigenschaften wieder eine Sprache.
Deswegen lässt sie die Theorie der von meinen Sprachen benutzen
Epsinon ist leere Wort, Emdy Set ist die leere Sprache. Und das Schöne ist jetzt,
diese Menge Operationen, die man machen kann,
Vereinigung und Schnitt, genau wie bei Mengen definiert, Kompliment,
ich nehme eben Sigmar Stern ohne L und dann Konkertenation ist noch wichtig,
dass ich sagen kann, wenn ich zwei Sprachen in der 1L12 habe,
dann ist eben die Konkertenation,
ich nehme einmal ein Wort wie 1 aus L1 und einmal ein Wort wie 2 aus L2 und wenn ich die Konkertiniere,
dann habe ich L1L2. Genau und dann der Klienstern oder Abschluss ist eben also L,
ho Stern, so ähnlich wie auch bei Sigmar Stern,
nur dass ich jetzt eben nicht einzelne Elemente aus Sigmar nehme und miteinander verbinde,
sondern einzelne Elemente aus L nehme und die miteinander verbinden.
Also ein L hoch 3 sind dann all die Elemente drin,
sodass ich drei Elemente aus L nehmen kann und die beliebe ich mir dann verbinden kann.
Und das eben auch wieder beliebig oft. Das heißt,
in L ho Stern sind Worte drin, die aus beliebig oft,
aber endlichem aneinanderreihen von Worten aus L entstehen. Beispiele,
wenn Sigmar A, B ist, oder 0-1,
in dem Beispiel ist jetzt A, B,
A ist die Menge, B ist die Menge und CSA-Stern.
Also ein C ist jetzt das leere Wort, A,
2 A ist 3 As, 4 As und so weiter.
A vereinigt mit B, einfach die Elemente alle zusammengeschmissen
A, geschnitten mit B, da bleibt irgendwie
nur das kleine A übrig, das in beiden ist.
C-Komplimente, schon ein lustiger C-Kompliment, ist die Worte rauszunehmen,
die nur aus As bestehen. Das heißt, da sind
all die Worte drin, die mindestens ein B enthalten.
Also irgendwie das Wort B, das wird B-A-A-B,
das Wort 2Bs, dann mit drei Buchstaben,
aber auf jeden Fall ist irgendwie ein B oder mindestens IB drin und immer so weiter.
Also all die Worte rausgenommen,
die kein B enthalten
Amal B, jetzt nehme ich all die Worte aus A und Konkatinil,
Konkatiniere nach und nach alle Worte aus B ran.
Das heißt, ich habe zuerst das Wort A aus der Menge A
und das Wort A aus der Menge B. Beide zusammen konkadiniert sind zwei As.
Dann habe ich irgendwie das Wort A und B-A,
das ist A-B-A. Dann fange ich hier an mit den zwei
aus und dem A, drei As und so weiter.
Ja, und zuletzt B-Stern, beliebig oft eins dieser beiden Wörter genommen und hintereinander geschrieben.
Also nullmal oder ich nehme genau ein Wort raus,
da habe ich A und B,
A oder ich nehme zweimal das A und konkonkatiniere das,
dann habe ich das hier oder ich nehme A und B A
und konkatiniere das oder ich nehme B-A und A und konkatiniere
das und
immer so weiter
Klar. Auch klar. Also mehr braucht man da jetzt
auch nicht an der Stelle. So,
und jetzt kann man nämlich dieses Entscheidungsproblem, das ist jetzt,
glaube ich, die letzte Folie dazu,
wenn Q jetzt so ein Entscheidungsproblem ist,
dann ist die Instanzenmenge ja durch Sigmar Stern gegeben.
Also irgendwelche Strings über 0 und 1. Und dann kann ich
das Entscheidungsproblem Q gerade durch die Instanzen charakterisieren,
die ja als Antwort haben.
Das heißt, ich nehme die Sprache eigentlich um,
so ein Entscheidungsproblem zu charakterisieren.
All die Wörter aus Sigmar Stern mit der Eigenschaft,
dass die zu 1 ausgewertet werden
Und bei sowas wie dem Kürzen Pfad oder so,
sind es dann eben genau die Instanzen, G-S-T-K mit der Eigenschaft.
Das ist in kürzesten Pfad von S-Z-T gibt, der Kleine gleich K ist.
Genau die Dinger sind da drin. Genau,
und da schreibt man dann irgendwie so, dass man sagt,
Pas, G-S-T-K mit, und jetzt halt dieser ganzen Eigenschaft,
da steht jetzt quasi die Problemstellung, dass man sagt,
G, ist ein ungerichteter Graf, Ess- und Thesen,
zwei Knoten, K ist eine Zahl,
Größe gleich Null.
Und es gibt so einen S-T-Pfad in G,
der aus höchstens Karakanten besteht. Und die eckigen Klammern hier,
die sollen dann eben die Koudierung andeuten, statt normale Runde Klammern,
kann auch Runde Klammern nehmen und noch eckige Klammern rummachen oder so.
Man kann das auch ganz weglassen,
wenn einem das Setting irgendwie klar ist
Aber so streng genommen, muss man irgendwie sagen, dass das eine Kulierung ist.
Genau, und jetzt geht es darum, Algorithmus zu entwickeln,
der bei Vorlage von so einem Tupel hier eben dieses Problem
auf der rechten Seite löst und dann entweder ja oder nein sagt.
Was der auch kriegen kann, ist ein taktischer Unsinn,
also irgendwelche Sachen, die gar nicht so ein Vierer-Tupel sind,
da kann er dann sofort nein sagen.
Und sonst, wenn er irgendwie so ein Tupel kriegt,
wo geht, tatsächlich ein Graf ist,
S und Tier Knoten sind von G und K irgendwie eine Zahl,
dann muss er eben gucken,
ist diese Eigenschaft hier erfüllt oder nicht.
Und wenn sie erfüllt ist, sagt er, ja,
und wenn sie nicht erfüllt ist, sagt er nein.
Also der entscheidet quasi, ob ein vorgegebenes Tupel GSTK
in dieser Menge Past drin ist oder nicht
So, sei alle gut, okay. Auf die Folie bin ich
gerade nicht vorbereitet. Genau, so soll das sein.
Wir drücken nun die Beziehung zwischen Entscheidungsproblemen. Achso, okay,
das ist im Grunde genommen aber das Gleiche wie das hier nochmal,
nur dass ich da jetzt nicht Kufonix hinschreibe,
sondern halt Algorithmus,
also A von
Also die Eingabe X-Element 0-1 Sternwert von A akzeptiert,
wenn Alex gleich eins gilt, okay,
und wenn Alex gleich null gilt,
wird X von A zurückgewiesen und dann ist die von A
akzeptierte Sprache eben gerade diese Menge X aus 0-1 Stern mit AX gleich eins.
Die hat mich deswegen überrascht, weil ich das eben schon alles erzählt habe,
ne? Genau, so. Und wichtig ist jetzt,
hier geht es jetzt darum, ob dieser Algorithmus diese Sprache akzeptiert.
Wenn ihr euch das anguckt hier, wichtig ist quasi,
dass der Algorithmus gar nicht zwingend sagt,
oder gar nicht zwingend abbrechen muss, wenn er was nicht akzeptiert.
Also wenn eine Sprache L akzeptiert wird,
muss nicht jedes X das nicht in LS zurückgewiesen werden
Das würde nämlich bedeuten, dass er stets anhält.
Wer FG1 gehabt hat, so dieses Halteproblem und so.
Aber man kann ja auch einen Algorithmus schreiben,
der irgendwie eine Endlohschleife kommt bei einer Instanz,
die er gar nicht akzeptieren will.
Das wäre nach dieser formalen Definition total okay. Entscheidende,
schöner. Eine Sprache wird von einem Algorithmus A entschieden,
wenn jedes X-Element aus 11 von A akzeptiert wird und jedes X,
was nicht in L ist, von A zurückgewiesen wird.
Und insbesondere diese letzte Zeile hier, die ist eben nicht gefordert,
wenn er nur die Sprache akzeptieren soll.
A, halt also insbesondere auf jeder Eingabe
an und liefert stets das richtige Ergebnis
Das hatten wir, glaube ich, schon, ne?
Genau, wieder Polymnialzeit, ne? Soll A,
die Sprache L entscheiden, wird für jeden Streaming-X der Länge
Ende in der Zeit Ofen-NOK entschieden, ob X&L gilt.
Und wenn er sie nur akzeptiert,
dann wird halt für jedes XNL in ZeitON noch K entschieden,
ob es akzeptiert wird oder nicht.
Aber eben nicht für die, die nicht drin sind.
Was man jetzt machen kann, ist,
jetzt definiert man sich diese Menge PSO, dass man sagt,
es existiert so ein Algorithmus, der L in Polymnialzeit entscheidet.
Man kann aber zeigen, dass es quasi egal ist,
ob ich sage,
akzeptiert oder entscheide
Da ist sie. Also hier definieren wir es jetzt,
dass die neue Definition, dass wir sagen,
es entscheidet das und wir wollen jetzt mal zeigen,
dass wenn ich eine Sprache entscheide,
dann ist das Gleiche, wie wenn ich sie akzeptiere.
Der Unterschied ist ja beim Akzeptieren, ich muss auf den 9-Instanzen nicht zwingend anhalten.
Wie kann man das lösen? Also dass wenn er ein Algorithmus dem Problem entscheidet,
der akzeptiert es auf jeden Fall auch, die Richtung ist einfach,
weil der entscheidet hält ja bei Ja und bei 9-Instanzen an,
der, der akzeptiert, muss ja nur bei Jahrenstanzen einhalten,
das tut er damit aber auch,
fertig.
Andersrum ist schwierig. Jetzt habe ich einen Algorithmus,
der das Problem akzeptiert
Und muss irgendwie das machen, dass er auch bei den Nein-Instanzen anhält.
Wie kriege ich das hin? Ich habe doch alle FG1 gehabt,
also außer du du, du musst die Lösung, ist okay, das ist super.
Wie hat man das gemacht? Genau, ganz einfach.
Bei dem L wird von einem Algorithmus ein Polymialzeit akzeptiert,
dann weiß ich ja, es gibt irgendwie eine Schranke P,
also ein Polynom, P von N,
im berechne ich zuerst das P von N und dann weiß ich
mir dann nach so viel Schritt noch nicht aufgehört hat,
dann wird er das Ding auch nicht mehr akzeptieren und dann kann ich das machen.
Ist nicht konstruktiv, weil ich das Polynom nicht zwingend kenne und sowas,
aber so von der Idee her,
wenn er was akzeptiert,
kann das auch entscheiden
Das ist halt dieser Vorteil bei den ganzen Komplexitätsklassen,
die entweder was mit Speicher oder Platz mit Speicher oder Zeit zu tun haben.
Ich kann mir quasi vorher die Schranke ausrechnen und dann gucken,
wenn ich rauskomme aus dieser Schranke, kann ich ablehnen.
Da steht es nochmal länglich, Richtung links nach rechts,
wenn er entscheidet, akzeptiert er auch,
dann ist zu zeigen, dass wenn ich Imponimialzeit,
eine Sprache im Stil, kann ich es auch entscheiden.
Wenn jetzt ein Algorithmus ist, der den Zeitufen dann noch akzeptiert,
dann gibt es so eine konstante C, sodass A,
die Sprache nach höchstens so viel Schritten akzeptiert.
Naja, und dann rechne ich das aus,
dieses Thema XOK und simuliere A dann erst schrittelang und Wenn er akzeptiert hat,
akzeptiere ich auch, wenn er abgelehnt hat,
lehne ich eben ab.
Wenn er immer noch arbeitet, lehne ich eben ab.
Und dann entscheide ich die Sprache. Genau, nicht konstruktiv
. Man weiß eventuell nicht, die polymierte Schranke.
Und oh ja, das machen wir noch. Jetzt kann
man noch, das hatten wir diese Operat, diese Sprachoperation.
Und jetzt kann man halt für jede von diesen Zeigen Vereinigung,
Schnitt, Konkertination, Kompliment und Sternbildung,
dass die Komplexitätsklasse P
dem gegenüber abgeschlossen ist
Das macht auch Sinn,
weil wenn ihr zum Beispiel sowas ihr habt, so ein Und,
dass wir programmiertechnisch im Grunde genommen die Frage irgendwie,
ihr kriegt eine Eingabe und, nee, Vereinigung vielleicht.
Nee, auch nicht. Und Vereinigung. Ja,
programmiertechnisch wäre es quasi, das Hintereinander ausführen oder das gleichzeitige Ausführen von Sachen.
Wenn ich L1 vereinigte L2 habe, also dass wir nicht zeigen,
dass das ein P ist und ich habe zwei Algorithmen in L1L2NT,
dann weiß ich ja, ich kann die Sprachen entscheiden.
Also ich halte sowohl auf ja jetzt auch auf 9-Instanzen an
Ja, dann kann ich sie jetzt hintereinander ausführen.
Ich führe zuerst L1 aus, wenn der Ja sagt,
ist gut, wenn der Nein sagt, führe ich danach L2 aus.
Wenn der Ja sagt, ist gut,
wenn der auch Nein sagt, dann ist es insgesamt nein.
Ups. Also es gibt Algorithmen A1, A2,
DL1 und L2 entscheiden und dann konstruiert man so ein Polymialzeitalgorithmus für den Einzel-2 wie folgt.
Bei Angabe X wird zunächst A1 von X berechnet.
Und weil ich hier eben Algorithmen genommen habe,
die die Sprachen entscheiden, halte ich auf jeden Fall an.
Wenn ich da schon die Antwort Ja kriege,
dann weiß ich ja, mein X ist also in L1 drin,
damit ist es auf jeden Fall auch in der Lines-Vereinigte zwei
drin.
Also kann ich
A sagen
Wenn ich die Antwort Nein kriege, also null,
dann weiß ich es nicht in L1 drin und gucke noch mal,
ob es in zwei drin ist, in L2 drin ist.
Und falls es da drin ist, akzeptiere ich,
wenn das auch eine Null ist, dann weiß ich,
das X ist weder in L1 noch ein L2,
also es ist auch nicht in der Vereinigung,
bin ich fertig.
Jetzt muss ich noch zeigen, jetzt habe ich nur gezeigt,
dass ich einen Algorithmus habe, der L1 vereinigt L2 entscheidet.
Jetzt muss ich noch zeigen, dass es auch ein Polymialzeit geht.
Das ist aber auch einfach Laufzeit von der Eins und A2
sind durch einen Polynom beschränkt, zwei Polynome hintereinander ausführen,
das ist immer noch ein Polynom.
Also das ist jetzt was,
was ich Endquanrad plus N hoch 3 oder so,
ist immer noch
ein Polynom
Da ist es noch einfach schwieriger zu argumentieren, dass man in Polymialzeit,
ist es bei sowas wie hier L1 mal L2 oder L1 Stern,
da wird das schwieriger. Dass man im Polymialzeit bleibt. Ja,
Zusammenfassung bis dahin, Eingabe im Soll, kodiert sein,
beneakuliert am besten und wir einigen uns auf solche Instanzen,
die irgendwie über 0-1 Sterne sind,
auch wenn wir das meistens eigentlich gar nicht brauchen.
Wichtig für uns ist,
Entscheidungsproblem ist dann einfach eine Sprache und wir können eben bei Eingabe X,
wollen wir einen Algorithmus konstruieren, der bei den Sachen,
die in Älteren sind, Ja sagt und bei den Sachen,
die nicht in Älteren sind, Nein sagen.
Und dann wollen wir uns vor allem mit Algorithmen beschäftigen,
die eben die Sprachen entscheiden,
sprich die auch bei den Worten,
die nicht in Älteren sind,
Und zuletzt, wenn es so ein Problem gibt,
für ein Algorithmus, das Problem Polinialz entscheidet,
dann sagen wir eben, dass L in P drin ist.
Und unser Ziel ist es immer noch, dass wir eigentlich zeigen können wollen,
dass ein L nicht in P drin ist.
Da wollen wir eigentlich hin. Beispiel hier Longist Pass-Ebene.
Da hatte ich ja irgendwie gesagt, da kriegen wir das
irgendwie nicht hin, einen effizienten Algorithmus zu entwerfen.
Und da ist jetzt die Frage, wie kann man dann irgendwie nachweisen,
dass das Problem eben wahrscheinlich nicht schnell lösbar ist?
Genau, schwierig zu lösen, zumindest effizient. Aber,
und das ist jetzt anders als das,
was wir in FG1 gemacht haben, gegeben so ein Pfad,
Also wenn ich euch die Eingabeinstanz GSTK gebe und ich gebe euch einen Pfad,
von dem ich jetzt behaupte, dass der länger ist als K. Naja,
überprüfen könnt ihr das schnell.
Es ist nur schwer, das auszurechnen.
Also es ist quasi schwer, auf diese Lösung zu kommen.
Aber wenn ich euch eine gebe und behaupte,
das ist eine Lösung, könnt ihr das schnell überprüfen.
Und das kann man bei ganz, ganz vielen Problemen machen.
Also bei einigen ist es auch schwer, eine Lösung zu überprüfen. Aber bei dem Problem,
die wir jetzt nachfolgend zu betrachten, ist es immer einfach,
wenn ich eine Lösung kriege oder eine behauptete Lösung,
ist es immer einfach zu überprüfen, ist das eine oder nicht.
Und auf diese Art und Weise kann man die Komplexitätsklasse NP
einführen und dann eben damit dann NP-Vollständigkeit.
Und wollt ihr Pause machen? Ja,
dann machen wir mal eine Viertelstunde Pause und dann machen wir
hier die letzten 14 Folien noch.