update

uni/aak/alle_hausaufgaben.txt

@@ -0,0 +1,817 @@
+                        CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                        Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                        Prof. Dr. K. Jansen, B. Schumacher, C. Wambsganz
+
+                                                                                  09.06.2025
+
+        Hausaufgaben zur Vorlesung »Analyse von Algorithmen und
+                             Komplexität«
+                                            Blatt 9
+
+
+Definition 1 (Vertex Cover (VC)). Für einen (ungerichteten) Graphen G = (V, E) ist ein Vertex
+Cover eine Menge von Knoten C ⊆ V , sodass u ∈ C oder v ∈ C für alle { u, v } ∈ E gilt, also ist
+für alle Kanten mindestens ein Endpunkt in C.
+Für das V ERTEX C OVER Problem ist neben einem Graphen G eine Zahl k ∈ N≥0 gegeben und
+es wird gefragt, ob ein Vertex Cover mit Größe (Anzahl der Knoten) höchstens k in G existiert.
+
+Definition 2 (Feedback Vertex Set (FVS)). Für einen gerichteten Graphen G = (V, E) ist ein
+Feedback Vertex Set eine Menge von Knoten X ⊆ V , sodass G \ X kreisfrei ist.
+Für das F EEDBACK V ERTEX S ET Problem ist neben einem Graphen G eine Zahl k ∈ N≥0 gege-
+ben und es wird gefragt, ob ein Feedback Vertex Set mit Größe (Anzahl der Knoten) höchstens
+k in G existiert.
+
+
+                            1                   6                     2
+
+
+                                        5
+                        8                             7
+                                                                  3
+                                            4
+                                 Abbildung 1: Beispiel Graph.
+
+Hausaufgabe 9.1 (Nichtdeterministischer Algorithmus für VC)                          (5 Punkte)
+   1. Finden Sie ein minimales Vertex Cover in Abbildung 1. Für ein Vertex Cover ist die
+      Orientierung der Kanten nicht relevant.
+   2. Zeigen Sie V ERTEX C OVER ∈ NP, indem Sie einen nichtdeterministischen Algorithmus
+      angeben, der V ERTEX C OVER in Polynomialzeit löst. Begründen Sie die Korrektheit und
+      die Laufzeit von Ihrem Algorithmus.
+
+Lösung.     1. Ein minimales Vertex Cover ist zum Beispiel { 3, 5, 6, 7, 8 }.
+   2. Unser nichtdeterministischer Algorithmus geht wie folgt vor: Für jeden Knoten wird
+      nichtdeterministisch entschieden, ob dieser im Vertex Cover sein soll. Nachdem dies für
+      alle Knoten entschieden wurde, wird überprüft, ob nicht mehr als k Knoten gewählt wur-
+      den und ob für jede Kante mindestens ein Endpunkt im Vertex Cover liegt.
+      Existiert ein Vertex Cover im Graphen, existiert auch eine Reihe von nichtdeterministi-
+      schen Entscheidungen, die diese Teilmenge von Knoten auswählt. Diese Teilmenge wird
+      dann auch von dem Algorithmus akzeptiert. Damit ist der Algorithmus korrekt.
+      Beide diese Schritte können naiv in Polynomialzeit erledigt werden, also löst dieser Al-
+      gorithmus das Vertex Cover Problem in Polynomialzeit.
+
+
+Bewertung 1 Punkt für das Beispiel und 4 Punkte für den Algorithmus, dabei 2 Punkte für
+die Beschreibung und jeweils 1 Punkt für Korrektheit und Laufzeit.
+
+Hausaufgabe 9.2 (Polynomieller Verifizierer für FVS)                                (5 Punkte)
+   1. Finden Sie ein minimales Feedback Vertex Set in Abbildung 1.
+   2. Zeigen Sie F EEDBACK V ERTEX S ET ∈ NP, indem Sie einen polynomiellen Verifizierer
+      für F EEDBACK V ERTEX S ET angeben. Begründen Sie die Korrektheit und die Laufzeit
+      von Ihrem Verifizierer.
+
+Lösung.     1. Ein minimales FVS ist zum Beispiel { 5, 6 }.
+   2. Das Zertifikat hat die Form einer Teilmenge X ⊆ V , die beschreibt, welche Knoten das
+      Feedback Vertex Set bilden sollen. Zum Beispiel über ein Bit pro Knoten. Nun wird
+      überprüft, ob |X| ≤ k gilt und ob G \ X azyklisch ist.
+      Hat der Graph ein Feedback Vertex Set von Größe maximal k, gibt es ein Zertifikat, wel-
+      ches dieses beschreibt. Dieses Zertifikat wird dann von unserem Verifizierer akzeptiert,
+      damit ist der Verifizierer korrekt.
+      Die Größe von X zu überprüfen ist naiv in Polynomialzeit möglich. Für den zweiten Test
+      bietet sich der Algorithmus zur topologischen Sortierung aus der Vorlesung an, welcher in
+      Polynomialzeit eine topologische Sortierung findet, wenn der gegebene Graph azyklisch
+      ist. Insgesamt ist dieser Verifizierer korrekt und auch ein polynomieller Verifizierer.
+
+
+Bewertung    1 Punkt für das Beispiel und 4 Punkte für den Verifizierer, dabei 2 Punkte für die
+Beschreibung und jeweils 1 Punkt für Korrektheit und Laufzeit.
+
+
+
+
+Abgabe: 16.06.2025, 10:00 in Moodle – bitte beachten Sie die Informationen zum Abgabefor-
+mat im Moodlekurs.
+                                       Hausaufgabe 9
+                                      Marek Lenczewski
+                                   Matrikelnummer: 1025252
+
+                                         22. Juni 2025
+
+
+Hausaufgabe 9.1
+Teil 1
+Ein minimales Vertex Cover ist C = {2, 7, 5, 4, 1}.
+Die Minimale Knotenanzahl ist 5.
+
+Teil 2
+Der Algorithmus arbeitet wie folgt:
+
+   • Zuerst wird für jeden Knoten v ∈ V nichtdeterministisch entschieden, ob dieser in das
+     Vertex Cover aufgenommen wird. Dabei wird drauf geachtet, dass die Anzahl k nicht
+     übersteigt.
+
+   • Danach wird geprüft, ob für jede Kante {u, v} ∈ E entweder v ∈ C oder u ∈ C oder beides
+     zutrifft.
+
+   • Falls dies für alle Kanten gilt, akzeptieren wir. Andernfalls lehnen wir ab.
+
+    Existiert ein Vertex Cover der Größe höchstens k, dann gibt es auch eine, nichtdeterminis-
+tisch ausgewählte, Knotenmenge, die dazu passt. Von dieser werden alle Kanten abgedeckt und
+der Algorithmus akzeptiert. Falls es kein Vertex Cover gibt, dann lehnt der Algorithmus ab.
+
+    Die Auswahl der Knoten und die Prüfung der Kanten läuft in polynomieller Zeit, also ist dies
+ein polynomieller nichtdeterministischer Algorithmus, der VERTEX COVER löst und damit ist
+V ERT EXCOV ER ∈ N P .
+
+
+Hausaufgabe 9.2
+Teil 1
+Ein minimales Feedback Vertex Set ist X = {1, 5}
+
+Teil 2
+Der Verifizierer arbeitet wie folgt:
+
+   • Es wird eine Teilmenge X ⊆ V übergeben, die das Feedback Vertex Set darstellen soll.
+
+   • Dann wird geprüft, ob |X| ≤ k gilt und es wird abgelehnt, falls es nicht gilt.
+
+   • Danach wird ein Graph G′ = G \ X konstruiert, in dem alle Knoten aus X und alle an X
+     angrenzenden Kanten entfernt wurden.
+
+                                                1
+   • Auf dem Graphen G′ wird eine Tiefensuche durchgeführt, dabei werden Knoten während
+     der Bearbeitung grau markiert und beim Backtracking schwarz.
+
+   • Wird eine Kante zu einem grauen Knoten entdeckt, dann wird abgelehnt, da dies einen
+     Kreis anzeigt.
+
+   • Falls die Tiefensuche den gesamten Graphen durchläuft ohne abzulehnen, dann wird ak-
+     zeptiert.
+
+   Existiert ein Feedback Vertex Set der Größe höchstens k, dann gibt es auch ein Zertifikat, das
+genau diese Knotenmenge beschreibt. Alle Teilmengen, die die Tiefensuche überstehen, werden
+von dem Verifizierer akzeptiert und sonst abgelehnt.
+
+    Die Prüfung der übergebenen Teilmenge und die Konstruktion des Graphen laufen in polyno-
+mieller Zeit. Ebenfalls die Tiefensuche läuft in polynomieller Zeit, somit ist auch der Verifizierer
+polynomiell und verifiziert die Lösung für das FEEDBACK VERTEX SET in polynomieller
+Zeit. Also gilt F EEDBACKV ERT EXSET ∈ N P .
+
+
+
+
+                                                 2
+                         CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                         Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                         Prof. Dr. K. Jansen, B. Schumacher, C. Wambsganz
+
+                                                                                  16.06.2025
+
+        Hausaufgaben zur Vorlesung »Analyse von Algorithmen und
+                             Komplexität«
+                                           Blatt 10
+
+
+Definition 1 (Feedback Vertex Set (FVS)). Für einen gerichteten Graphen G = (V, E) ist ein
+Feedback Vertex Set eine Menge von Knoten X ⊆ V , sodass G \ X kreisfrei ist.
+Für das F EEDBACK V ERTEX S ET Problem ist neben einem Graphen G eine Zahl k ∈ N≥0 gege-
+ben und es wird gefragt, ob ein Feedback Vertex Set mit Größe (Anzahl der Knoten) höchstens
+k in G existiert.
+
+Hausaufgabe 10.1 (F EEDBACK V ERTEX S ET ist NP-vollständig)                          (5 Punkte)
+Zeigen Sie, dass F EEDBACK V ERTEX S ET NP-vollständig ist.
+Hinweis: Reduzieren Sie V ERTEX C OVER auf F EEDBACK V ERTEX S ET. Wenn ein Vertex Cover
+aus einem Graphen entfernt wird, hat dieser keine Kanten mehr.
+
+Lösung. F EEDBACK V ERTEX S ET ∈ NP ist bekannt aus der letzten Hausaufgabe. Nun zeigen
+wir eine Reduktion von V ERTEX C OVER auf F EEDBACK V ERTEX S ET. Betrachte die folgende
+Reduktion:
+Für eine gegebene V ERTEX C OVER Instanz (G = (V, E), k) erzeuge den Graphen G′ = (V, E ′ )
+mit E ′ := { (u, v), (v, u) | {u, v} ∈ E }. Gebe (G′ , k) als F EEDBACK V ERTEX S ET Instanz aus.
+Korrektheit:
+⇒ (Falls (G, k) eine Ja-Instanz von V ERTEX C OVER ist, dann ist (G′ , k) eine Ja-Instanz von
+F EEDBACK V ERTEX S ET.):
+Sei C ⊆ V ein Vertex Cover mit Größe kleiner oder gleich k. Dann enthält G \C keine Kanten.
+Damit hat G′ \C ebenfalls keine Kanten und somit keine Kreise.
+⇐ (Falls (G′ , k) eine Ja-Instanz von F EEDBACK V ERTEX S ET ist, dann ist (G, k) eine Ja-Instanz
+von V ERTEX C OVER.):
+Sei X ⊆ V ′ ein Feedback Vertex Set mit Größe kleiner oder gleich k. Dann ist X ein Vertex
+Cover in G, da ansonsten eine Kante {u, v} ∈ E existiert, für die u ∈
+                                                                    / X ∧v ∈
+                                                                           / X gilt. Damit wäre
+aber (u, v, u) ein Kreis in G′ und X somit kein Feedback Vertex Set.
+Laufzeit: Das Erzeugen der Menge E ′ geht in Zeit O(|E|). Insgesamt ist die Reduktion dem-
+nach in Laufzeit O(|E|), also in polynomieller Laufzeit, durchführbar.
+Also existiert eine polynomielle Reduktion von V ERTEX C OVER auf F EEDBACK V ERTEX S ET.
+Da V ERTEX C OVER nach den aktuellen Präsenzaufgaben NP-vollständig ist und
+F EEDBACK V ERTEX S ET ∈ NP gilt, ist somit F EEDBACK V ERTEX S ET NP-vollständig.
+Bewertung 2 Punkte für die Konstruktion, 1 Punkt für den 1. Fall, 1 Punkt für den 2. Fall,
+0.5 Punkte für die Laufzeit, 0.5 Punkte für die Beweisführung im Ganzen
+
+Hausaufgabe 10.2 (Turingmaschinen)                                                (5 Punkte)
+Entwerfen Sie eine Turingmaschine für die Sprache L = { w ∈ Σ∗ | w ist ein Palindrom } über
+einem gegebenen Alphabet Σ und geben Sie die Laufzeit Ihrer Turingmaschine an. Begründen
+Sie dabei, warum Ihre Turingmaschine korrekt ist und die angegebene Laufzeit hat.
+
+Lösung. Die Turingmaschine sieht folgendermaßen aus:
+ (1) Falls kein Wort auf dem Band steht, akzeptiere.
+ (2) Falls nur ein Buchstabe auf dem Band steht, akzeptiere.
+ (3) Lese den ersten Buchstaben und bewege danach den Kopf zum letzten Buchstaben. Falls
+     die beiden Buchstaben verschieden sind, verwerfe. Ansonsten ersetze beide Buchstaben
+     durch ein neues Symbol x. Ersetze dafür zuerst den letzten Buchstaben und bewege dann
+     den Kopf zum ersten Buchstaben.
+ (4) Gehe zu Schritt (1).
+Korrektheit: Die Turingmaschine vergleicht immer den ersten und den letzten Buchstaben.
+Wenn die Buchstaben nicht gleich sind, ist das Wort kein Palindrom und es wird verworfen.
+Ansonsten werden die Buchstaben rausgestrichen (siehe Schritt (3)). Diese Prozedur wird so-
+lange wiederholt, bis man in der Mitte des Wortes angekommen ist und entweder nur noch ein
+Buchstabe oder kein Buchstabe vorhanden ist. In beiden Fällen ist das Wort ein Palindrom und
+es wird akzeptiert (siehe Schritte (1) und (2)).
+Laufzeit: Die Schritte (1) bis (3) benötigen jeweils eine Laufzeit von O(n), wobei n hier die
+Länge der Eingabe bezeichnet. Da in jedem Durchlauf der Schritte (1) bis (3) zwei Buchstaben
+raus gestrichen werden oder das Wort akzeptiert oder verworfen wird, gibt es maximal ⌊n/2⌋
+Durchläufe, bis nur noch ein oder kein Buchstabe auf dem Band stehen und somit in den Schrit-
+ten (1) oder (2) akzeptiert wird. Damit ergibt sich insgesamt eine Laufzeit von O(n2 ).
+
+
+Bewertung      2 Punkte für die Turingmaschine, 1 Punkt für die Korrektheit und 2 Punkte für
+die Laufzeit: 1 Punkt Angabe, 1 Punkt Begründung
+
+
+
+
+Abgabe: 23.06.2025, 10:00 in Moodle – bitte beachten Sie die Informationen zum Abgabefor-
+mat im Moodlekurs.
+                                    Hausaufgabe 10
+                                     Marek Lenczewski
+                                  Matrikelnummer: 1025252
+
+                                          22. Juni 2025
+
+
+Hausaufgabe 10.1
+Teil 1: FeedbackVertexSet ∈ NP
+   Zuerst brauchen wir einen polynomiellen Verifizierer, um zu zeigen dass FeedbackVertexSet
+∈ NP.
+
+   Der Verifizierer bekommt einen Graphen G und eine Teilmenge X, dieser arbeitet wie folgt:
+
+   • Prüfe, ob |X| ≤ k, sonst ablehnen
+
+   • Den Graphen G′ = G \ X konstruieren
+
+   • Tiefensuche auf G′ durchführen, dabei werden Knoten vom aktuellen Pfad als grau mar-
+     kiert und nach vollständiger Bearbeitung als schwarz. Wird eine Kante zu einem grauen
+     Knoten gefunden, zeigt dies einen Kreis an und wir lehnen ab
+
+   • Akzeptieren, wenn die Tiefensuche nichts findet
+
+    Die Schritte 1-4 laufen in polynomieller Zeit, somit läuft der Verifizierer in polynomieller
+Zeit. Damit ist F eedbackV ertexSet ∈ N P .
+
+   Teil 2: FeedbackVertexSet ist NP-schwer
+   Jetzt brauchen wir eine Reduktion von VertexCover auf FeedbackVertexSet, um zu zeigen,
+dass F eedbackV ertexSet N P − Schwer ist.
+
+    Konstruktion: Sei dafür ein VertexCover gegeben mit einem Graphen G und einer Zahl k.
+Aus G wird ein G′ , wobei jede ungerichtete Kante {u, v} ∈ E durch zwei gerichteten Kanten
+(u, v) und (v, u) zu E ′ ersetzt wird. Das k wird einfach übernommen k = k ′ .
+
+   Beweis VertexCover nach FeedbackVertexSet:
+
+   • Sei C ein VertexCover von G mit |C| ≤ k
+
+   • Da C ein VertexCover ist, wird jede Kante mit C verbunden
+
+   • Wenn C entfernt wird, dann hat G \ C keine Kanten mehr
+
+   • Dann hat auch G′ \ C keine Kanten und ist somit Kreisfrei
+
+   • Damit ist C ein FeedbackVertexSet für G′ mit |C| ≤ k ′
+
+
+
+   Beweis FeedbackVertexSet nach VertexCover:
+
+                                               1
+   • Sei X ein FeedbackVertexSet von G′ mit |X| ≤ k ′
+
+   • Dann ist G′ \ X kreisfrei
+
+   • Angenommen X wäre kein VertexCover von G, dann gäbe es eine Kante {u, v} ∈ E mit
+     u, v ∈
+          /X
+
+   • Somit wären u, v noch in G′ \ X vorhanden
+
+   • Die Kanten (u, v) und (v, u) würden, durch die Konstruktion, einen Kreis erzeugen
+
+   • Das ist ein Widerspruch, somit ist G′ \ X kreisfrei und X ist ein VertexCover
+
+   Da F eedbackV ertexSet ∈ N P und N P − schwer ist, folgt dass F eedbackV ertexSet NP-
+Vollständig ist.                                                                     □
+
+
+Hausaufgabe 10.2
+Lösung. Die Turingmaschine arbeitet wie folgt:
+
+  1. Falls das Band leer ist oder nur aus Markierungen besteht, akzeptiere
+
+  2. Merke das erste unmarkierte Zeichen und ersetze es durch X
+
+  3. Laufe zum letzten unmarkierten Zeichen oder verwefe
+
+  4. Falls dieses Zeichen nicht mit dem gemerkten übereinstimmt, verwerfe
+
+  5. Ersetze es durch X und gehe zurück zum Anfang
+
+  6. Gehe zu 1
+
+    Korrektheit: Ein Wort ist genau dann ein Palindrom, wenn es sich von vorne und hin-
+ten gleich liest. Dies prüft die Turingmaschine, indem sie Schrittweise die äußeren Buchstarben
+verifiziert, bis nur noch einer oder keiner Vorhanden ist, dann akzeptiert ist und wenn eine Un-
+stimmigkeit auftritt, dann lehnt sie ab.
+
+   Laufzeit: Die Turingmaschine hat eine Laufzeit von O(n2 ). In jedem Durchlauf macht sie
+O(n) Schritte und das mit O(n) Durchläufen.                                            □
+
+
+
+
+                                               2
+                         CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                         Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                         Prof. Dr. K. Jansen, B. Schumacher, C. Wambsganz
+
+                                                                                   23.06.2025
+
+        Hausaufgaben zur Vorlesung »Analyse von Algorithmen und
+                             Komplexität«
+                                            Blatt 11
+
+
+Definition 1 (Dreiecksüberdeckung eines Graphen (∆ C OVER)). Gegeben ist ein endlicher un-
+gerichteter Graph G = (V, E) und eine Zahl k ∈ N. Dieser Graph hat eine Dreiecksüberdeckung,
+wenn eine Menge von Knoten C∆ ⊆ V mit |C∆ | ≤ k existiert, so dass zu jedem Teilgraphen (Drei-
+eck) D = (VD , ED ) ⊆ (V, E) mit |VD | = 3 und ED = { {v1 , v2 } ∈ VD ×VD | v1 ̸= v2 } von G gilt,
+v ∈ C∆ für mindestens ein v ∈ VD .
+
+Hausaufgabe 11.1                                                                     (10 Punkte)
+
+
+  (a) (1 Punkt) Markieren Sie im folgenden Graphen (Abbildung 1 (a)) ein V ERTEX C OVER
+      der Größe 5.
+  (b) (1 Punkt) Markieren Sie im folgenden Graphen (Abbildung 1 (b)) eine Dreiecksüberde-
+      ckung der Größe 5.
+  (c) (8 Punkte) Zeigen Sie, dass ∆ C OVER NP-vollständig ist.
+
+
+
+
+                       (a)                                              (b)
+
+                                  Abbildung 1: Beispielgraph
+
+
+Lösung.
+                          (a)                                                  (b)
+
+                                  Abbildung 2: Beispielgraph Lösung
+
+
+(c) Wir zeigen zunächst, ∆ C OVER ∈ NP mittels eines polynomiellen Verifizierers.
+ Der polynomielle Verifizierer erhält als Zertifikat eine Menge von Knoten C∆ ⊆ V . Zunächst
+ überprüft er, ob |C∆ | ≤ k. Falls dies nicht der Fall ist, verwerfe die Instanz. Ansonsten überprüfe
+ für alle Teilgraphen D = (VD , ED ) ⊆ (V, E) mit |VD | = 3 und ED = { {v1 , v2 } ∈ VD ×VD | v1 ̸= v2 }
+ von G, ob für mindestens ein v ∈ VD auch v ∈ C∆ gilt. Falls dies gilt, akzeptiere. Ansonsten ver-
+ werfe.
+ Korrektheit: Der Verifizierer überprüft die geforderten Eigenschaften. Falls ein Graph eine Drei-
+ ecksüberdeckung besitzt, so existiert ein entsprechendes Zertifikat C∆ und der Verifizierer ak-
+ zeptiert die Instanz. Falls ein Graph keine Dreiecksüberdeckung besitzt, exisitert kein valides
+ entsprechendes Zertifikat C∆ und der Verifizierer verwirft die Instanz.
+ Laufzeit: Es gibt maximal |V |3 verschiedene Teilmengen, die ein Dreieck bilden könnten und
+ daher überprüft werden müssen. Die Überprüfung geht in O(|V |) Zeit. Da alle anderen Schritte
+ des Verifizierers in O(1) Zeit erledigt werden können, ergibt sich somit insgesamt eine Laufzeit
+ von O(|V |4 ), was einer polynomiellen Laufzeit entspricht.
+ Also gilt ∆ C OVER ∈ NP.
+ Nun reduzieren wir V ERTEX C OVER auf ∆ C OVER. Betrachte folgende Reduktion:
+ Sei I = (G = (V, E), k) eine Instanz von V ERTEX C OVER. Bilde den Graphen G′ = (V ′ , E ′ ) mit
+ V ′ = V ∪ { ve | e ∈ E } und E ′ = E ∪ { {ve , e1 }, {ve , e2 } | e = {e1 , e2 } ∈ E }. Gebe I ′ = (G′ , k)
+ als ∆ C OVER Instanz aus.
+ Korrektheit:
+ ⇒ (Falls (G, k) eine Ja-Instanz von V ERTEX C OVER ist, dann ist (G′ , k) eine Ja-Instanz von ∆
+ C OVER.):
+ Sei C ein Vertex Cover mit Größe kleiner oder gleich k von G. Dann ist C ebenfalls eine Drei-
+ ecksüberdeckung mit Größe kleiner oder gleich k. Offensichtlich gilt |C| ≤ k. Da C ein Vertex
+ Cover von G ist, gilt für jede Kante {u, v} ∈ E, dass u ∈ C oder v ∈ C. Für alle Teilgraphen
+ D = (VD , ED ) ⊆ (V, E) mit |VD | = 3 und ED = { {v1 , v2 } ∈ VD ×VD | v1 ̸= v2 } von G gilt damit
+ direkt, dass mindestens ein v ∈ VD auch in C enthalten ist. Der Graph G′ besitzt neben allen
+ solchen Teilgraphen in G zusätzlich solche Teilgraphen (Dreiecke), die durch die Knotenmenge
+{ ve | e ∈ E } und die entsprechenden Kanten { e, {ve , e1 }, {ve , e2 } | e = {e1 , e2 } ∈ E } entste-
+hen. Für diese Dreiecke gilt aber auch, dass mindestens ein Knoten, nämlich e1 oder e2 , in C
+enthalten sein muss, da C ein Vertex Cover ist.
+⇐ (Falls (G′ , k) eine Ja-Instanz von ∆ C OVER ist, dann ist (G, k) eine Ja-Instanz von V ERTEX -
+C OVER.):
+Sei C∆ eine Dreiecksüberdeckung von G′ der Größe |C∆ | ≤ k. Ohne Beschränkung der All-
+gemeinheit können wir davon ausgehen, dass C∆ ⊆ V gilt: Falls für einen Knoten ve ∈ C∆ gilt,
+können wir e1 zu C∆ hinzufügen und ve aus C∆ löschen. Dadurch bleibt die Überdeckungseigen-
+schaft erhalten und die Menge wird höchstens kleiner. Nun gilt also C∆ ⊆ V . Die Menge C∆ ist
+auch ein Vertex Cover mit Größe kleiner oder gleich k von G. Offensichtlich gilt |C∆ | ≤ k. Da für
+alle Teilgraphen D′ = (VD′ , ED′ ) ⊆ (V ′ , E ′ ) mit |VD′ | = 3 und ED′ = { {v1 , v2 } ∈ VD′ ×VD′ | v1 ̸= v2 }
+von G′ gilt, dass mindestens ein Knoten v ∈ VD′ ebenfalls in C∆ enthalten sein muss, gilt dies
+auch für die Dreiecke {ve , e1 , e2 }. Da außerdem C∆ ⊆ V gilt, gilt e1 ∈ C∆ oder e2 ∈ C∆ für alle
+Kanten e ∈ E.
+Laufzeit: Das Hinzufügen von einem neuen Knoten und zwei neuen Kanten pro Kante geht in
+O(|E|). Damit geht die gesamte Reduktion in O(|E|), also in polynomieller Zeit.
+Also existiert eine polynomielle Reduktion von V ERTEX C OVER auf ∆ C OVER. Da V ERTEX -
+C OVER NP-vollständig aus den Präsenzaufgaben bekannt ist und ∆ C OVER ∈ NP gilt, ist somit
+∆ C OVER NP-vollständig.
+
+
+Bewertung (a) und (b) jeweils 1 Punkt, (c) gibt 8 Punkte: 1 Punkt Angabe Verifizierer/NDTM,
+0,5 Punkte Korrektheit Verifizierer/NDTM, 0,5 Punkte Laufzeit Verifizierer/NDTM, 1 Punkt
+Angabe Reduktion, 3 Punkte Korrektheit (je Richtung 1,5 Punkte), 1 Punkt Laufzeit Reduktion,
+1 Punkt Beweisführung
+
+
+
+
+Abgabe: 30.06.2025, 10:00 in Moodle – bitte beachten Sie die Informationen zum Abgabefor-
+mat im Moodlekurs.
+                               Hausaufgabe 11
+                              Marek Lenczewski
+                           Matrikelnummer: 1025252
+
+                                   28. Juni 2025
+
+
+Hausaufgabe 11.1
+a
+                                     1
+
+
+                               2             3
+
+
+                               4             5
+
+
+                                     6             10
+
+
+                                     7             9
+
+
+                                             8
+
+
+b
+                           a         b       c
+
+
+                           d                 e
+                       f                                g
+
+                           h                 i          j
+
+
+                           k         l       m          n
+                           o                 p              q
+                                     r                  s
+
+
+                                     t       u          v
+
+
+c
+Teil 1: ∆-Cover ∈ NP
+
+
+                                         1
+   Zuerst brauchen wir einen polynomiellen Verifizierer, um zu zeigen, dass ∆-Cover ∈ NP.
+Der Verifizierer bekommt einen Graphen G = (V, E), Zahl k und ein Zertifikat C∆ ⊆ V und
+arbeitet wie folgt:
+
+
+  1. Prüfe, ob |C∆ | ≤ k
+  2. Prüfe alle Knotentripel {a, b, c} ⊆ V , ob sie ein Dreieck bilden (also ob {a, b}, {b, c} und
+     {a, c} ∈ E zutrifft) und ob a, b oder c ∈ C∆
+  3. Ablehnen, falls ein Dreieck den test nicht besteht, sonst akzeptieren
+
+   Die Schritte 1 und 3 laufen in O(1) und Schritt zwei läuft in O(|V |3 ), das ergibt eine poly-
+nomielle Laufzeit. Damit ist ∆-Cover ∈ NP.
+
+  Teil 2: ∆-Cover ist NP-schwer
+  Jetzt brauchen wir eine Reduktion von VertexCover auf ∆-Cover, um zu zeigen, dass
+∆-Cover NP-schwer ist.
+
+    Konstruktion: Sei dafür ein VertexCover gegeben mit einem Graphen G = (V, E) und
+einer Zahl k. Aus G wird G′ = (V ′ , E ′ ), wobei für jede Kante e = {u, v} ∈ E ein neuer Kno-
+ten we ∈ V ′ hinzugefügt wird und mit beiden Knoten u, v verbunden wird, sodass die Kanten
+{v, we } und {u, we } zu E ′ dazu kommen. Das k = k ′ wird übernommen. So werden aus allen
+Kanten Dreiecke.
+
+   Beweis VertexCover nach ∆-Cover
+   • Sei C ein VertexCover für G mit |C| ≤ k
+   • Zu zeigen sei, dass C auch ein ∆-Cover für G′ mit |C| ≤ k ist
+   • Da C ein VertexCover ist, gilt u ∈ C oder v ∈ C
+   • Jedes Dreieck in G′ hat die Form {u, v, we } für eine Kante e = {u, v} ∈ E
+   • Somit hat jedes Dreieck mindestens einen Knoten in C
+   • Also ist C ein ∆-Cover für G′
+   Beweis ∆-Cover nach VertexCover
+   • Sei C∆ ein ∆-Cover für G′ mit |C∆ | ≤ k ′
+   • Jede Kante e = {u, v} ∈ E bildet durch {u, v, we } ein Dreieck in G′
+   • Also gilt u, v oder we ∈ C∆ für alle Kanten in G′
+   • Falls we ∈ C∆ , dann kann man we durch u oder v tauschen ohne die Eigenschaft von
+     ∆-Cover zu verletzen, sodass u oder v ∈ C∆ für alle Kanten in G′ gilt
+   • Da sich die Knoten aus C∆ nur vertauschen gilt weiter |C| = |C∆ | ≤ k
+   • Weiter sind in C∆ nur noch die Knoten aus V , somit gilt u ∈ C oder v ∈ C für alle Kanten
+     E
+   • Also ist C ein VertexCover für G
+
+
+
+   Da ∆-Cover ∈ NP und NP-schwer ist, folgt dass ∆-Cover NP-vollständig ist.                    □
+
+                                                  2
+                          CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                          Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                          Prof. Dr. K. Jansen, B. Schumacher, C. Wambsganz
+
+                                                                                        30.06.2025
+
+         Hausaufgaben zur Vorlesung »Analyse von Algorithmen und
+                              Komplexität«
+                                              Blatt 12
+
+
+Hausaufgabe 12.1 (Lower Bound: V ERTEX C OVER)                                  (5 Punkte)
+Betrachten Sie die Reduktion aus der Musterlösung zu Präsenzserie 10 von C LIQUE auf V ER -
+TEX C OVER .
+
+   1. Geben Sie die Anzahl der Knoten, die Anzahl der Kanten und den Wert k für die re-
+      sultierende V ERTEX C OVER Instanz in Abhängigkeit von der originalen C LIQUE Instanz
+      an.
+   2. Zeigen Sie Lower Bounds für V ERTEX C OVER bezüglich Anzahl der Knoten, Anzahl
+      der Kanten und k basierend auf der ETH und der Reduktion aus der Musterlösung zu
+      Präsenzserie 10.
+
+Lösung.      1. Sei I = (G = (V, E), k) eine Instanz von C LIQUE und I ′ = (G′ = (V ′ , E ′ ), k′ ) die
+     aus der Reduktion resultierende Instanz von V ERTEX C OVER. Es gilt |V ′ | = |V |, |E ′ | =
+     1                            2     ′
+     2 |V |(|V | − 1) − |E| ≤ |V | und k = |V | − k ≤ |V |.
+                                                                                            ′
+   2.     • Angenommen es gäbe einen Algorithmus, der V ERTEX C OVER in 2o(|V |) · |I|O(1)
+            löst. Durch die Kombination der Reduktion von C LIQUE auf V ERTEX C OVER und
+            diesem Algorithmus, existiert dann auch ein 2o(|V |) ·|I|O(1) Algorithmus für C LIQUE,
+            da |V ′ | = |V | nach Aufgabenteil 1. Aus der Musterlösung der Präsenzserie 12 folgt
+            somit, dass die ETH falsch ist.
+            Damit kann es so einen Algorithmus für V ERTEX C OVER nur geben, wenn die ETH
+            falsch ist.
+                                                                                    √ ′
+          • Angenommen es gäbe einen Algorithmus, der V ERTEX C OVER in 2o( |E |) · |I|O(1)
+            löst. Durch die Kombination der Reduktion von C LIQUE auf V ERTEX C OVER und
+            diesem Algorithmus, existiert dann auch ein 2o(|V |) ·|I|O(1) Algorithmus für C LIQUE,
+            da |E ′ | ≤ |V |2 nach Aufgabenteil 1. Aus der Musterlösung der Präsenzserie 12 folgt
+            somit, dass die ETH falsch ist.
+            Damit kann es so einen Algorithmus für V ERTEX C OVER nur geben, wenn die ETH
+            falsch ist.
+                                                                                        ′
+          • Angenommen es gäbe einen Algorithmus, der V ERTEX C OVER in 2o(k ) · |I|O(1) löst.
+            Durch die Kombination der Reduktion von C LIQUE auf V ERTEX C OVER und die-
+            sem Algorithmus, existiert dann auch ein 2o(|V |) · |I|O(1) Algorithmus für C LIQUE,
+            da k′ ≤ |V | nach Aufgabenteil 1. Aus der Musterlösung der Präsenzserie 12 folgt
+            somit, dass die ETH falsch ist.
+            Damit kann es so einen Algorithmus für V ERTEX C OVER nur geben, wenn die ETH
+            falsch ist.
+Bewertung       1 Punkt für den ersten Teil und 1.5 + 1.5 + 1 für den zweiten.
+
+Definition 1 (H ITTING S ET). Bei diesem Problem ist ein Universum U, Teilmengen des Uni-
+versums F1 , . . . , Fr ⊆ U und eine Zahl k ∈ N≥0 gegeben. Gibt es eine Menge S ⊆ U mit |U| ≤ k
+und S ∩ Fi ̸= 0/ für alle i ∈ [r]?
+Anschaulicher wird bei diesem Problem nach maximal k Elementen aus dem Universum ge-
+fragt, sodass diese Elemente alle gegebenen Mengen Fi „treffen“.
+
+Hausaufgabe 12.2 (Lower Bound: H ITTING S ET)                                               (5 Punkte)
+Betrachten Sie folgende Reduktion von 3-SAT auf H ITTING S ET.
+Für eine gegebene 3-SAT Instanz I mit n Variablen x1 , . . . , xn und m Klauseln C1 , . . . ,Cm : Als
+Universum wählen wir U = { x1 , x̄1 , . . . , xn , x̄n }. Für jede Variable xi fügen wir die Menge Fi :=
+{ xi , x̄i } hinzu. Für jede Klausel C j fügen wir die Menge Fn+ j := C j hinzu. Wir setzen k := n
+und erhalten damit eine H ITTING S ET Instanz I.
+   1. Geben Sie die Größe des Universums, die Anzahl der Mengen und die Zahl k aus der
+      resultierenden H ITTING S ET Instanz in Abhängigkeit von der Anzahl der Variablen n und
+      der Anzahl der Klauseln m aus der originalen 3-SAT Instanz an.
+   2. Beweisen Sie Lower Bounds für H ITTING S ET bezüglich Universumsgröße, Anzahl der
+      Mengen und der Zahl k basierend auf der obigen Reduktion und der ETH.
+
+Lösung.    1. Für die Universumsgröße gilt |U| = 2n, für die Anzahl der Mengen gilt r =
+     n + m und es gilt k = n.
+   2.     • Angenommen es gäbe einen Algorithmus, der H ITTING S ET in 2o(|U|) · |I|O(1) löst.
+            Durch die Kombination der Reduktion von 3-SAT auf H ITTING S ET und diesem
+            Algorithmus, existiert dann auch ein 2o(n) · |I|O(1) Algorithmus für 3-SAT, da |U| =
+            2n nach Aufgabenteil 1. Damit ist die ETH falsch.
+            Damit kann es so einen Algorithmus für H ITTING S ET nur geben, wenn die ETH
+            falsch ist.
+          • Angenommen es gäbe einen Algorithmus, der H ITTING S ET in 2o(r) · |I|O(1) löst.
+            Durch die Kombination der Reduktion von 3-SAT auf H ITTING S ET und diesem
+            Algorithmus, existiert dann auch ein 2o(m) · |I|O(1) Algorithmus für 3-SAT, da r =
+            n + m nach Aufgabenteil 1 und n ≤ 3m für 3-SAT gilt. Aus dem Sparsification
+            Lemma folgt damit, dass die ETH falsch ist.
+            Damit kann es so einen Algorithmus für H ITTING S ET nur geben, wenn die ETH
+            falsch ist.
+          • Angenommen es gäbe einen Algorithmus, der H ITTING S ET in 2o(k) · |I|O(1) löst.
+            Durch die Kombination der Reduktion von 3-SAT auf H ITTING S ET und diesem
+            Algorithmus, existiert dann auch ein 2o(n) · |I|O(1) Algorithmus für 3-SAT, da k = n
+            nach Aufgabenteil 1. Damit ist die ETH falsch.
+            Damit kann es so einen Algorithmus für H ITTING S ET nur geben, wenn die ETH
+            falsch ist.
+
+
+Bewertung       1 Punkt für den ersten Teil und 1.5 + 1.5 + 1 für den zweiten.
+
+Abgabe: 07.07.2025, 10:00 in Moodle – bitte beachten Sie die Informationen zum Abgabefor-
+mat im Moodlekurs.
+                                     Hausaufgabe 12
+                                      Marek Lenczewski
+                                   Matrikelnummer: 1025252
+
+                                           6. Juli 2025
+
+
+Hausaufgabe 12.1.1
+Die Knotenzahl bleibt gleich: |V ′ | = |V | = n
+Die Kantenzahl entspricht den nicht vorhandenen Kanten: |E ′ | = |E|
+k ′ entspricht allen Knoten, die vorher nicht in der Clique waren: k ′ = n − k
+
+
+Hausaufgabe 12.1.2
+Wir wissen, dass 3-SAT laut ETH mindestens 2Ω(n) braucht, wobei n für die Anzahl der Varia-
+blen steht.
+
+    In der Vorlesung wurde eine Reduktion von 3-SAT auf Clique gezeigt. In der Präsenzaufgabe
+10.2 wurde eine Reduktion von Clique auf VertexCover gezeigt. Also gibt es eine Reduktion von
+3-SAT zu VertexCover. Somit kann VertexCover nicht schneller lösbar sein als 3-SAT, weil sonst
+3-SAT schneller werden würde, was nach ETH nicht geht.
+
+   So ergeben sich die folgenden Lower Bounds:
+
+   • Bezüglich Anzahl der Knoten: 2Ω(n) , wobei n = |V ′ |. Die Knotenzahl verändert sich
+     nicht bei den Reduktionen.
+                                               √
+   • Bezüglich Anzahl der Kanten: 2Ω( m) , wobei m = |E ′ |. Die Kanten können bei den
+     Reduktionen zu einem quadratischen Wachstum der Kanten führen.
+                          ′
+   • Bezüglich k ′ : 2Ω(k ) . Bei der Reduktion gilt k ′ = n − k, wobei k ′ linear von n abhängt.
+
+
+
+
+                                                   1
+Hausaufgabe 12.2.1
+   • Größe des Universums: |U | = 2n. Für jede der n Variablen gibt es zwei Elemente (xi
+     und xi )
+
+   • Anzahl der Mengen: n + m. n sind die Variablenmengen und m die Klauselmengen. (Fi
+     und Fn+j )
+
+   • Parameter: k = n. Wird in der Reduktion so übernommen.
+
+
+Hausaufgabe 12.2.2
+Wir wissen, dass 3-SAT laut ETH mindestens 2Ω(n) braucht, wobei n für die Anzahl der Varia-
+blen steht. Somit kann HittingSet nicht schneller sein.
+
+   Es ergeben sich die folgenden Lower Bounds für HittingSet:
+
+   • Bezüglich Größe des Universums: 2Ω(|U |/2) , da für jede Variable zwei Elemente ins
+     Universum aufgenommen werden
+
+   • Bezüglich Anzahl der Mengen: 2Ω(n) , wobei die Anzahl der Variablen- und Klausel-
+     mengen (m + n) mindestens n ist
+
+   • Bezüglich Zahl k: 2Ω(k) , da in der Reduktion k = n gilt.
+
+
+
+
+                                              2
+                         CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                         Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                         Prof. Dr. K. Jansen, B. Schumacher, C. Wambsganz
+
+                                                                                    07.07.2025
+
+        Hausaufgaben zur Vorlesung »Analyse von Algorithmen und
+                             Komplexität«
+                                             Blatt 13
+
+
+Definition 1 (M AX -3-S AT). Bei dem Problem M AX -3-S AT ist eine Formel φ in konjunktiver
+Normalform gegeben, wobei jede Klausel 3 Literale enthält. Gesucht ist eine Belegung β der
+Variablen, die die Anzahl v(β ) der erfüllten Klauseln maximiert.
+
+Hausaufgabe 13.1 (M AX -3-S AT)                                                       (10 Punkte)
+Betrachten Sie folgenden Algorithmus A:
+   • Sei β0 die Belegung, die alle Variablen auf false setzt.
+   • Sei β1 die Belegung, die alle Variablen auf true setzt.
+   • Falls v(β0 ) ≥ v(β1 ), gib β0 zurück.
+   • Sonst gib β1 zurück.
+
+  (a) (6 Punkte) Zeigen Sie, dass obiger Algorithmus Güte 2 hat, d.h. v(A(φ )) ≥ 12 v(OPT (φ ))
+      gilt für alle Eingaben φ .
+ (b) (4 Punkte) Geben Sie eine Formel an, bei der der Algorithmus eine Belegung ausgibt, die
+     genau die Hälfte der maximal erfüllbaren Klauseln erfüllt. Begründen Sie kurz, warum
+     Ihre Formel geeignet ist.
+      Hinweis: Sie brauchen nur höchstens zwei Klauseln und vier Variablen.
+
+Lösung. (a) Für jede Klausel C gilt, dass sie von mindestens einer der Belegungen β0 und
+     β1 erfüllt wird. Wir zeigen nun per Widerspruch, dass der obige Algorithmus eine Güte
+     von 2 hat:
+      Angenommen, es gilt v(A(φ )) < 12 v(OPT (φ )) für eine Formel φ . Sei m die Anzahl an
+      Klauseln in φ . Dann gilt v(OPT (φ )) ≤ m. Da v(A(φ )) < 12 v(OPT (φ )) ≤ 12 m, gilt v(β0 ) <
+      1                 1
+      2 m und v(β1 ) < 2 m. Da jede Klausel C allerdings von mindestens einer der Belegungen
+      β0 und β1 erfüllt wird, gilt v(β0 ) ≥ 12 m oder v(β1 ) ≥ 12 m. Dies ist ein Widerspruch.
+      Also gilt v(A(φ )) ≥ 21 v(OPT (φ )) für alle Eingaben φ und obiger Algorithmus hat Güte
+      2.
+ (b) Betrachte folgende Formel: φ = (x1 ∨x2 ∨x3 )∧(¬x0 ∨¬x2 ∨¬x3 ) Mit β = {x0 → f alse, x1 →
+     true, x2 → true, x3 → true} gilt v(β ) = 2. Da φ nur zwei Klauseln hat, gilt somit v(OPT (φ )) =
+     2. Es gilt allerdings v(β0 ) = 1, da hier nur die zweite Klausel erfüllt ist, und v(β1 ) = 1,
+     da hier nur die erste Klausel erfüllt ist. Somit gilt v(A(φ )) = 1 = 12 · 2 = 21 v(OPT (φ )).
+Bewertung (a) 2 Punkte korrekte Beweisführung im Allgemeinen, 2 Punkte Abschätzung
+Algorithmus, 2 Punkte Abschätzung Optimum; (b) 2 Punkte für Angabe einer korrekten Formel,
+1 Punkt Ausgabe Algorithmus, 1 Punkt Optimum
+
+
+
+
+Abgabe: 14.07.2025, 10:00 in Moodle – bitte beachten Sie die Informationen zum Abgabefor-
+mat im Moodlekurs.
+                                     Hausaufgabe 13
+                                     Marek Lenczewski
+                                  Matrikelnummer: 1025252
+
+                                          13. Juli 2025
+
+
+Hausaufgabe 13.1.a
+Zu zeigen ist, dass der Algorithmus die Güte 2 hat, also die Lösung vom Algorithmus mindestens
+halb so gut ist wie die optimale Lösung. Also ν(A(ϕ)) ≥ 21 ν(OP T (ϕ)) für alle Eingaben ϕ.
+
+   Sei ϕ eine beliebige 3-SAT-Formel mit m Klauseln C1 , C2 , . . . , Cm , wobei jede Klausel genau
+3 Literale enthält.
+
+   Jede Klausel Ci ist wahr, wenn β0 wahr ist oder wenn β1 wahr ist oder beides. Da die Varia-
+blen in Ci nur positiv oder negativ sein können, muss dabei mindestens β0 oder β1 wahr werden.
+
+   Der Algorithmus wählt die Belegung β0 oder β1 aus, die die meisten Klauseln Ci erfüllt.
+Somit ist die Anzahl der ausgewählten Klauseln Ci mindestens m2 , da eine bei jeder Klausel
+mindestens eine Belegung wahr werden muss und somit hat mindestens eine Belegung mindes-
+tens m
+     2 wahre Klauseln.
+
+   Sei ν0 = Anzahl der von β0 erfüllten Klauseln und ν1 = Anzahl der von β1 erfüllten Klauseln.
+
+   So ergibt sich ν(A(ϕ)) = max{ν0 , ν1 } ≥ ν0 +ν
+                                               2
+                                                  1
+                                                    ≥m
+                                                     2.
+
+   Da die optimale Lösung höchstens alle m Klauseln erfüllen kann, gilt ν(OP T (ϕ)) ≤ m.
+                               ν(OP T (ϕ))
+   Daraus folgt: ν(A(ϕ)) ≥ m
+                           2 ≥     2       .
+
+   Somit hat der Algorithmus eine Güte von 2.
+
+
+
+
+                                                1
+Hausaufgabe 13.1.b
+Der Algorithmus erfüllt genau die Hälfte der maximal erfüllbaren Klauseln, wenn jede Klausel
+nur aus positiven oder negativen Variablen besteht und sich diese genau gleich aufteilen.
+
+   Formel: ϕ = (x1 ∨ x2 ∨ x3 ) ∧ (¬x1 ∨ ¬x2 ∨ ¬x3 )
+
+   Unter β0 (alle false):
+
+   • C1 = (x1 ∨ x2 ∨ x3 ) = (false ∨ false ∨ false) = false
+
+   • C2 = (¬x1 ∨ ¬x2 ∨ ¬x3 ) = (true ∨ true ∨ true) = true
+
+   • ν(β0 ) = 1
+
+   Unter β1 (alle true):
+
+   • C1 = (x1 ∨ x2 ∨ x3 ) = (true ∨ true ∨ true) = true
+
+   • C2 = (¬x1 ∨ ¬x2 ∨ ¬x3 ) = (false ∨ false ∨ false) = false
+
+   • ν(β1 ) = 1
+
+   Der Algorithmus wählt ν(A(ϕ)) = max{ν(β0 ), ν(β1 )} = max{1, 1} = 1.
+
+   Eine optimale Lösung wäre zum Beispiel x1 = true, x2 = false, x3 = false.
+
+   • C1 = (true ∨ false ∨ false) = true
+
+   • C2 = (false ∨ true ∨ true) = true
+
+   Daraus ergibt sich ν(OP T (ϕ)) = 2, also ν(A(ϕ)) = ν(OP2T (ϕ)) . Somit hat es die Güte 2.
+
+
+
+
+                                                 2
+

uni/aak/alle_klausuren.txt

@@ -0,0 +1,863 @@
+                             CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                             Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                             Prof. Dr. K. Jansen
+
+                                                                                             19. Juli 2024
+
+                        Modulprüfung zur Vorlesung
+        »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«
+                                               SS 2024
+    Name:                                       Matrikel-Nr.:
+
+
+   Hinweise:
+
+   • Bearbeiten Sie alle Aufgaben.
+   • Sie haben 10 Minuten Einlesezeit. Danach haben Sie 120 Minuten Zeit für die Klausurbearbeitung.
+   • Erlaubte Hilfsmittel: Ein doppelseitig handschriftlich beschriebenes Blatt Papier, (bunte) Stifte (kein
+     Rot, kein Grün, kein Bleistift).
+   • Einsichtnahme: 18.08.2024.
+      Note                 4,0    3,7   3,3    3,0    2,7 2,3 2,0 1,7 1,3 1,0
+   •
+      Mindestpunkzahl 17,5 19,5 21,5 23,5 25 27 29 31 33 35
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                        Seite 1 von 12
+Aufgabe 1 KOMPLEXITÄT: A NWENDUNG LPT (4+2+2+2 Punkte)
+    Gegeben ist folgende Scheduling Instanz:
+     Jj   J1   J2   J3   J4   J5   J6   J7
+                                                  m=3
+     pj   5    3    7    8    1    4    2
+
+    a) Wenden Sie den LPT-Scheduling Algorithmus auf die obige Instanz an. Geben Sie dafür alle
+       relevanten Zwischenschritte an, sowie die Reihenfolge in der die Jobs auf Maschinen platziert
+       werden. Stellen Sie den resultierende Schedule graphisch dar. Eine beispielhafte Darstellung
+       ist:
+
+                                             J3
+                                                    J6
+                                             J2
+                                                    J5          J7
+                                             J1
+                                                    J4
+                                             m1     m2         m3
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                 Seite 2 von 12
+    b) Geben Sie die approximative Güte des Algorithmus LPT an.
+
+
+
+
+    c) Geben Sie eine Instanz für m = 2 Maschinen an, bei denen der Algorithmus ListScheduling
+       eine Güte von 2 − 1/m erzielt. Geben Sie zusätzlich an, welche Werte die optimale Lösung
+       OPT und die Lösung von LPT für diese Instanz erzielen.
+
+
+
+
+    d) Geben Sie eine Instanz für m = 3 Maschinen an, bei denen der Algorithmus ListScheduling
+       eine Güte von 2 − 1/m erzielt. Geben Sie zusätzlich an, welche Werte die optimale Lösung
+       OPT und die Lösung von LPT für diese Instanz erzielen.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«             Seite 3 von 12
+Aufgabe 2 KOMPLEXITÄT: B EWEIS : K -C LIQUE (10 Punkte)
+    Beweisen Sie folgende Aussage aus der Vorlesung:
+    SAT ≤ k-Clique.
+    Hinweis: NICHT 3-SAT, sondern allgemeines SAT!
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 4 von 12
+Aufgabe 3 KOMPLEXITÄT: NP-VOLLSTÄNDIGKEIT (5+5 Punkte)                                                   a)
+       Wir betrachten folgendes Problem:
+        Problem: CliqueAndIndependetSet
+        Eingabe: Ein ungerichteter Graph G = (V, E) mit V = 1, . . . , |V | und eine ganze Zahl k ≥ 1.
+        Entscheide: Gibt es in G sowohl ein Independent Set (Menge von Knoten, die paarweise
+        nicht adjazent sind, d.h. zwischen denen es keine Kanten gibt) der Größe k und als auch eine
+        Clique der Größe k?
+       Zeigen Sie die NP-Schwere von CliqueAndIndependetSet durch Angabe einer Reduktion
+       eines nach Vorlesung/Übung bekanntermaßen NP-schweren Problems.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                   Seite 5 von 12
+    b) Wir betrachten folgendes Problem:
+       Problem: (a1 = 1)-SubsetSum
+       Eingabe: Eine Menge von n Items, jedes Item i ∈ [n] hat eine Größe ai ∈ N>0 , wobei a1 = 1,
+       und ein Zielwert T .
+       Entscheide: Gibt es I ⊆ [n] sodass ∑i∈I ai = T ?
+       Zeigen Sie die NP-Schwere von (a1 = 1)-SubsetSum durch Angabe einer Reduktion eines
+       nach Vorlesung/Übung bekanntermaßen NP-schweren Problems.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                Seite 6 von 12
+Aufgabe 4 KOMPLEXITÄT: A PPROXIMATIVE A LGORITHMEN (3+7 Punkte)
+    Wir betrachten folgendes Problem:
+    Problem: A PPROXIMATE S UBSET S UM
+    Eingabe: n ganze Zahlen a1 , . . . an und ein Zielwert T . Es gilt ai ≤ T ∀i ∈ [n] sowie ∑i∈[n] ai >
+    T.
+    Ziel: Wähle Zahlenmenge S ⊆ {1, . . . n} mit ∑ j∈S a j ≤ T und maximiere ∑ j∈S a j .
+
+    Betrachten Sie zu diesem Problem den folgenden Algorithmus GA.
+
+    Algorithmus GA((A,T))
+
+     1   sortiere Zahlen absteigend, sodass a1 ≥ a2 ≥ · · · ≥ an gilt;
+     2   integer i = 1;
+     3   integer sum = 0;
+     4   boolean tooLarge = false;
+     5   while i ≤ n and tooLarge = false do
+     6     if sum+ai ≤ T then
+     7        sum=sum+ai ;
+     8        i = i + 1;
+     9     else
+    10        tooLarge = true;
+    11     fi
+    12   od
+    13   return sum;
+
+    a) Geben Sie eine Konstruktionsvorschrift für eine Instanz I an, mit der der Algorithmus GA
+       beliebig nah an eine Güte von 2 kommt, also A(I) ≈ OPT2 (I) .
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                     Seite 7 von 12
+    b) Zeigen Sie, dass der Algorithmus GA eine approximative Güte von 2 hat, also A(I) ≥ OPT2 (I)
+       gilt.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                Seite 8 von 12
+Aufgabe 5 KOMPLEXITÄT: ETH (5+5 Punkte)
+
+    a) Betrachten Sie nachfolgende Reduktion von 3-SAT auf k-Color:
+       1. Eliminiere doppelte Klauseln und Variablen, die in keiner Klausel auftauchen
+       2. Elimiere Klauseln die eine Variable und ihre Negation enthalten (diese sind immer erfüllt)
+       3. Seien C1 , . . . ,Cm die Klauseln in der SAT Formel
+       4. Definiere                                                  
+                                   V := { xi , x̄i , vi | i ∈ [n] } ∪ C j j ∈ [m] ∪ {z} ,
+          sowie
+                                 
+                            E := {vi , v j }, {vi , x j }, {vi , x̄ j } i ∈ [n], j ∈ [n] \ {i}
+                              ∪ { {xi , x̄i } | i ∈ [n] }
+                                
+                              ∪ {xi ,C j } i ∈ [n], j ∈ [m], xi ∈        / Cj
+                                
+                              ∪ {x̄i ,C j } i ∈ [n], j ∈ [m], x̄i ∈      / Cj
+                              ∪ { {vi , z} | i ∈ [n] }
+                                
+                              ∪ {C j , z} j ∈ [m]
+       Welche Lower Bounds ergeben sich unter Annahme der ETH for k-Colour aus dieser Re-
+       duktion in Hinblick auf
+         (i) die Anzahl der Knoten |V |; sowie
+        (ii) die Anzahl der Kanten |E|?
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                             Seite 9 von 12
+    b) Wir betrachten folgendes Scheduling Problem:
+        Problem: 2|prec, pi ∈ {1, 2}|Cmax
+        Eingabe: Eine Menge J von n Jobs, jeder Job J ∈ J hat eine Ausführungszeit pJ ∈ {1, 2}
+        sowie Präzedenzconstraints in Form eines gerichteten, azyklischem Graphen G = (J , A),
+        sowie ein ganze Zahl T ≥ 0.
+        Entscheide: Existiert ein Schedule, d.h. eine Abbildung, die jedem Job eine Startzeit und
+        eine Maschine zuweist, sodass (a) sich Jobs auf einer Maschine nicht überlappen (b) für alle
+        Jobs j, k ∈ J mit ( j, k) ∈ A, dass k erst startet nachdem j vollständig abgearbeitet ist und
+        (c) der Makespan höchstens T ist?
+       Wir betrachten die folgende Reduktion von k-Clique auf 2|prec, pi ∈ {1, 2}|Cmax .
+       Seien G = (V, E) und k gegeben. Wir setzen n = 4|V | + 3|E| und erstellen einen Knoten-Job Ji
+       für alle i ∈ V mit pi = 1. Des Weiteren erstellen wir Kanten-Jobs J{i, j} für jede Kante {i, j} ∈ E
+       mit p{i, j} = 2. Abschließend erstellen wir noch 3|V | + 2|E| Dummy Jobs. Diese Jobs haben
+       Ausführungszeit pdummy = 1.
+       Wir setzen unsere Präzedenzen nach dem folgenden Schema:
+       1) (Ji , J{i, j} ) für alle i ∈ V, {i, j} ∈ E
+       2) Präzedenzen innerhalb der Dummy Jobs.
+       Zuletzt setzen wir den Makespan T = 2|V | + 2|E|.
+         (i) Geben Sie die Lower Bounds für 2|prec, pi ∈ {1, 2}|Cmax in Hinblick auf n an, die sich
+             unter der ETH aus dieser Reduktion, basierend auf den Lower Bounds für k-Clique,
+             ergeben.
+        (ii) Geben Sie die Lower Bounds für 2|prec, pi ∈ {1, 2}|Cmax in Hinblick auf T an, die sich
+             unter der ETH aus dieser Reduktion, basierend auf den Lower Bounds für k-Clique,
+             ergeben.
+       Hinweis: Ein beispielhafter Schedule ist unten dargestellt. Die Präzedenzen sind im Graphen
+       durch gerichtete Kanten abgebildet, daher startet J4 erst nach dem Ende von J1 . Nutzen Sie
+       für diese Aufgabe die bekannten Lower Bounds aus der Präsenzübung. Diese wurden aus der
+       Reduktion von 3-SAT auf k-Clique hergeleitet. Hierbei ist der Clique Graph zusammenhän-
+       gend!
+
+                                                                               J3
+
+                                                                  J1
+                                J3          J4
+                                                                               J4
+
+                                J1                                J2
+                                            J2
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                     Seite 10 von 12
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 11 von 12
+Aufgabe 6 B ONUSAUFGABE (10 Punkte)
+    Beweisen oder widerlegen Sie folgende Aussage:
+    Wenn die ETH fehlschlägt gilt P = NP.
+
+
+
+
+                                       Viel Erfolg!
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 12 von 12
+                             CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                             Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                             Prof. Dr. K. Jansen
+
+                                                                                        11. Oktober 2024
+
+                        Modulprüfung zur Vorlesung
+        »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«
+                                               SS 2024
+    Name:                                       Matrikel-Nr.:
+   Hinweise:
+
+   • Bearbeiten Sie alle Aufgaben.
+   • Sie haben 10 Minuten Einlesezeit. Danach haben Sie 120 Minuten Zeit für die Klausurbearbeitung.
+   • Erlaubte Hilfsmittel: Ein doppelseitig handschriftlich beschriebenes Blatt Papier, (bunte) Stifte (kein
+     Rot, kein Grün, kein Bleistift).
+   • Einsichtnahme: 30.10.2024
+             Note          4,0      3,7   3,3   3,0 2,7 2,3 2,0 1,7 1,3 1,0
+   •
+      Mindestpunktzahl 17,5 19,5 21,5 23,5 25 27 29 31 33 35
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                        Seite 1 von 16
+Aufgabe 1 ∆T SP1 (6+2+2 Punkte)
+    Gegeben sei folgender Graph G = (V, E), bei dem die Kantengewichte jeweils an der nach außen
+    gerichteten Seite der Kante stehen:
+
+                                                        a
+                                        4                               2
+
+                                                        3
+                                e                                               b
+                                                4               2
+
+                                    4                                       3
+                                                    6       5
+
+                                            d                       c
+                                                        2
+
+    a) Wenden Sie den Algorithmus ∆T SP1 auf den Graphen G beginnend bei a an. Geben Sie dabei
+       die Ergebnisse jedes Zwischenschrittes des Algorithmus an.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                Seite 2 von 16
+    b) Beschreiben Sie, was der Algorithmus ∆T SP1 berechnet und geben Sie die Bedingungen an,
+       die an den Graphen gestellt sind, damit der Algorithmus eine korrekte Lösung berechnet.
+
+
+
+
+    c) Begründen Sie, warum der Algorithmus ∆T SP1 eine approximative Güte von 2 besitzt.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«             Seite 3 von 16
+Aufgabe 2 KOMPLEXITÄT: VORLESUNGSBEWEIS SAT (10 Punkte)
+    Beweisen Sie folgende Aussage:
+    3-SAT ist NP-vollständig. Zeigen Sie dafür SAT ≤ 3-SAT, nehmen Sie also 3-SAT ∈ NP als
+    gegeben an.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«         Seite 4 von 16
+Aufgabe 3 KOMPLEXITÄT: NP-VOLLSTÄNDIGKEIT (5+5 Punkte)
+
+    a) Wir betrachten folgendes Problem:
+       Problem: Hitchhiker’s-HamiltonianCycle
+       Eingabe: Ein ungerichteter Graph G = (V, E) mit V = {1, . . . , |V |} und für alle v ∈ V gilt
+       deg(v) ≥ 42.
+       Entscheide: Gibt es einen Hamiltonkreis in G?
+       Beweisen Sie die NP-Schwere von Hitchhiker’s-HamiltonianCycle durch Angabe einer
+       Reduktion eines nach Vorlesung/Übung bekanntermaßen NP-schweren Problems.
+       Hinweis: Als Hilfe, geben Sie graphisch die Reduktion für Knotengrad ≥ 10 an.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                 Seite 5 von 16
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 6 von 16
+    b) Wir betrachten folgendes Problem:
+        Problem: AtMostTwoPerSize-SubsetSum
+        Eingabe: Ein ganzzahliger Zielwert T > 0, eine Menge von n Items, jedes Item i ∈ [n]
+        hat eine Größe ai ∈ N>0 , jede Größe tritt höchstens zwei Mal auf, d.h. für alle i ∈ [n] gilt
+        | { i′ ∈ [n] | ai′ = ai } | ≤ 2.
+        Entscheide: Gibt es S ⊆ [n] sodass ∑i∈S ai = T ?
+       Beweisen Sie die NP-Schwere von AtMostTwoPerSize-SubsetSum durch Angabe einer Re-
+       duktion eines nach Vorlesung/Übung bekanntermaßen NP-schweren Problems.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                  Seite 7 von 16
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 8 von 16
+Aufgabe 4 KOMPLEXITÄT: A PPROXIMATIVE A LGORITHMEN (10+(10) Punkte)
+    Wir betrachten das aus der Vorlesung bekannte Makespan Scheduling Problem P||Cmax . Dazu ist
+    folgender Algorithmus gegeben:
+
+    Algorithmus ROUND ROBIN S CHEDULING(I=(J,m))
+
+      1   sortiere die Jobs in J so, dass p1 ≥ p2 ≥ · · · ≥ pn gilt;
+      2   setze B1 = · · · = Bm = 0;
+                                  /
+      3   integer j = 1;
+      4   integer i = 1;
+      5   while j <= n do
+      6     Platziere Job J j auf Maschine Mi ;
+      7     Bi = Bi ∪ {J j };
+      8      j = j + 1;
+      9     if i < m then
+     10        i=i+1
+     11     else
+     12        i=1
+     13     fi
+     14   od
+     15   return B1 , . . . , Bm
+
+    Betrachten Sie folgendes Beispiel zu der Funktionsweise des Round Robin Scheduling Algorith-
+    mus’. Gegeben sind 3 Maschinen und 6 Jobs J1 , . . . J6 , die bereits richtig sortiert sind. Es gilt
+    p1 = 7, p2 = 5, p3 = 5, p4 = 4, p5 = 3, p6 = 1. Daraus ergibt sich folgender Schedule:
+
+
+
+
+                                        J4
+
+                                                    J5
+                                                                 J6
+
+                                        J1
+                                                    J2           J3
+
+
+                                        m1          m2          m3
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                     Seite 9 von 16
+    a) Zeigen Sie per Widerspruch, dass der Algorithmus Round Robin Scheduling eine approxima-
+       tive Güte von 2 hat.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«           Seite 10 von 16
+    b) BONUS: Geben Sie die Konstruktionsvorschrift für eine Instanz an, mit der der Algorithmus
+       Round Robin Scheduling beliebig nah an eine Güte von 2 kommt, also A(I) ≈ 2 · OPT (I).
+       Nutzen Sie dafür mindestens 3 Maschinen und 7 Jobs, womit eine Rate von A(I) = 53 OPT
+       zu erreichen ist. Geben sie die optimale Makespan an und die, die der Algorithmus bei Ihrer
+       Instanz erreicht. Für eine Güte von 53 können bis zu 3 Punkten erreicht werden, bei einer
+       Güte von 47 sind bis zu 5 Punkte zu erreichen. Geben Sie eine Konstruktionsvorschrift an,
+       bei denen bei einer beliebigen, festen Anzahl von Maschinen m eine Güte von 2 − m1 erreicht
+       wird, können Sie die vollen 10 Punkte erreichen.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«              Seite 11 von 16
+Aufgabe 5 KOMPLEXITÄT: ETH (5+5 Punkte)
+
+    a) Wir betrachten folgendes Problem:
+        Problem: DominatingSet
+        Eingabe: Ein ungerichteter Graph G = (V, E) mit V = 1, . . . , |V | und eine Ganzzahl k ≥ 1.
+        Entscheide: Gibt es eine Menge M ⊆ V der Kardinalität |M| = k derart, dass jeder Knoten
+        v ∈ V entweder in M ist oder zu einem Knoten in M benachbart ist.
+       Wir untersuchen nun folgende Reduktion von 3-SAT auf DominatingSet:
+       1. Seien C1 , . . . ,Cm die Klauseln der 3-SAT-Formel
+       2. Seien x1 , . . . , xn die Variablen der 3-SAT-Formel
+       3. Erzeuge die Knoten xi , xi und di für jede Variable xi
+       4. Erzeuge die Kanten {xi , xi }, {xi , di } und {di xi } für jede Variable xi
+       5. Für jede Klausel C j erzeuge einen Knoten C j
+       6. Für jedes Literal ℓ einer Klausel C j erzeuge die Kanten {C j , ℓ}
+       Welche unteren Schranken für die Laufzeit folgen damit für DominatingSet unter der ETH
+       in Bezug auf
+         (i) die Anzahl der Knoten |V |?
+        (ii) die Anzahl der Kanten |E|?
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                Seite 12 von 16
+    b) Wir betrachten folgendes Problem:
+       Problem: GridTiling
+       Eingabe: Zwei ganze Zahlen k und j und für jedes i ∈ [k] und j ∈ [k] eine Menge Si, j ⊆ [n]2 .
+       Entscheide: Gibt es (ei, j )(i, j)∈[k]2 derart, dass
+        1. für alle (i, j) ∈ [k]2 gilt ei, j ∈ Si, j ;
+        2. für alle i ∈ [k] und j ∈ [k − 1] gilt für ei, j = (a, b) und ei, j+1 = (a′ , b′ ), dass a = a′ (dh. die
+           ausgewählten Tupel müssen in der ersten Komponente übereinstimmen, wenn der erste
+           Index derselbe ist); und
+        3. für alle i ∈ [k − 1] und j ∈ [k] gilt für ei, j = (a, b) und ei+1, j = (a′ , b′ ), dass b = b′ (dh.
+           die ausgewählten Tupel müssen in der zweiten Komponente übereinstimmen, wenn der
+           zweite Index derselbe ist)
+       Betrachten Sie folgende Beispielinstanz für k = 2, die Elemente der Lösung sind unterstrichen:
+
+
+                        S1,1 = {(1, 1), (2, 2)}                               S1,2 = {(1, 2), (2, 1), (2, 2)}
+
+
+
+                        S2,1 = {(1, 2), (2, 1)}                                   S2,2 = {(1, 1), (2, 2)}
+
+
+       Wir untersuchen folgende Reduktion von Clique:
+       1. Sei G = (V, E) und eine Zahl k als zu untersuchende Clique Instanz gegeben
+       2. Wir nehmen ohne Beschränkung der Allgemeinheit an, dass V = {1, . . . , |V |} sowie k ≥ 2
+          gilt und dass keine isolierten Knoten existieren.
+       3. Wir übernehmen den Wert von k
+       4. Für jedes Paar (i, j) ∈ [k]2 definieren wir
+                                          (
+                                           { (a, a) | a ∈ V }              if i = j
+                                 Si, j :=
+                                           { (a, b) | a ̸= b, {a, b} ∈ E } if i ̸= j
+       Welche unteren Schranken für die Laufzeit folgen damit für Grid Tiling (mit der aus der
+       Vorlesung bekannten Reduktion von Clique auf 3-SAT) in Hinblick auf
+         (i) der Gesamtanzahl X := ∑(i, j)∈[k]2 |Si, j | der Tupel in den Mengen; sowie
+        (ii) der maximalen Anzahl Y := max(i, j)∈[k]2 |Si, j | an Tupeln in einer der Mengen?
+       Hinweis: Aus der Reduktion in der Vorlesung wissen wir, dass Clique selbst dann noch NP-
+       schwer ist, wenn k ∈ Θ(|V |) gilt. Sie dürfen also annehmen, dass es eine (globale) Konstante
+       c > 0 gibt, sodass c · n ≤ k ≤ n.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                            Seite 13 von 16
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 14 von 16
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 15 von 16
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 16 von 16
+                             CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                             Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                             Prof. Dr. K. Jansen
+
+                                                                                             14. Juli 2023
+
+                        Modulprüfung zur Vorlesung
+        »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«
+                                               SS 2023
+    Name:                                       Matrikel-Nr.:
+
+
+   Hinweise:
+
+   • Bearbeiten Sie alle Aufgaben.
+   • Sie haben 10 Minuten Einlesezeit. Danach haben Sie 120 Minuten Zeit für die Klausurbearbeitung.
+   • Erlaubte Hilfsmittel: Ein doppelseitig handschriftlich beschriebenes Blatt Papier, (bunte) Stifte (kein
+     Rot, kein Grün, kein Bleistift).
+   • Einsichtnahme: Nach Absprache.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                        Seite 1 von 11
+Aufgabe 1 RUCKSACKPROBLEM (3+2+5 Punkte)
+    Wir betrachten die Anwendung der Approximationsheuristiken für das Rucksackproblem aus der
+    Vorlesung.
+    Gegeben sei dafür folgende Instanz des Rucksackproblems mit Kapazität B = 16. Items sind in
+    der Form (pi , wi ) angegeben.
+                       I = [(1, 4), (1, 1), (1, 3), (11, 13), (3, 3), (5, 6), (1, 5), 16]
+    a) Wenden Sie den normalen Greedy-Algorithmus auf obige Instanz an. Begründen Sie kurz,
+       warum die gewählten Items ausgewählt werden. Was ist der Lösungswert?
+
+
+
+
+    b) Wenden Sie nun den ModifiedGreedy-Algorithmus an. Wie ändert sich die Lösung?
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                        Seite 2 von 11
+    c) Was ist die Güte des ModifiedGreedy-Algorithmus? Geben Sie eine kurze Idee an, wie man
+       diesen Ansatz modifizieren kann, um die Güte auf 32 oder 43 zu verbessern.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«           Seite 3 von 11
+Aufgabe 2 L ONGEST PATH (3+3+4 Punkte)
+    Betrachten Sie das folgende Problem:
+    Problem: L ONGEST PATH
+    Eingabe: Eine ungerichteter Graph G = (V, E) und eine Zahl k.
+    Entscheide: Gibt es einen Pfad in G, der mindestens Länge k hat?
+
+    Zeigen Sie auf verschiedene Weisen, dass das Problem in NP liegt:
+
+    a) Geben Sie ein Zertifikat für L ONGEST PATH an.
+    b) Beschreiben Sie einen Verifizierer für L ONGEST PATH und geben Sie dessen Laufzeit konkret
+       an.
+    c) Beschreiben Sie eine nicht-deterministische Turing-Maschine (in Worten), die L ONGEST PATH
+       löst. Geben Sie auch hier die Laufzeit konkret an.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«               Seite 4 von 11
+Aufgabe 3 A PPROXIMATIVE A LGORITHMEN (6+4 Punkte)
+    Das Problem M AX -3-S AT sei folgendermaßen definiert:
+    Problem: M AX -3-S AT
+    Eingabe: Eine Formel φ in konjunktiver Normalform, wobei jede Klausel drei Literale enthält.
+    Ausgabe: Eine Belegung β der Variablen, die die Anzahl v(β ) der erfüllten Klauseln maximiert.
+
+    Betrachten Sie folgenden Algorithmus A:
+
+       • Sei β0 die Belegung, die alle Variablen auf false setzt.
+       • Sei β1 die Belegung, die alle Variablen auf true setzt.
+       • Falls v(β0 ) ≥ v(β1 ), gib β0 zurück.
+       • Sonst gib β1 zurück.
+
+    a) Zeigen Sie, dass obiger Algorithmus Güte 2 hat, d.h. A(φ ) ≥ 12 OPT (φ ) gilt für alle Eingaben
+    φ.
+    b) Geben Sie eine Formel an, bei der der Algorithmus eine Belegung ausgibt, die genau die Hälfte
+    der maximal erfüllbaren Klauseln erfüllt. Begründen Sie kurz, warum Ihre Formel geeignet ist.
+    Hinweis: Sie brauchen nur höchstens zwei Klauseln und sechs Variablen.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                   Seite 5 von 11
+Aufgabe 4 B EWEIS ZUR VORLESUNG (10 Punkte)
+    Betrachten Sie folgendes Problem aus der Vorlesung:
+
+    Problem: k-C LIQUE
+    Eingabe: Ein ungerichteter Graph G = (V, E) und eine Zahl k ≥ 1. Eine Clique ist eine Teil-
+    menge C ⊆ V mit {u, v} ∈ E für alle u, v ∈ C mit u ̸= v.
+    Entscheide: Hat der gegebene Graph G eine Clique C ⊆ V mit mindestens k Knoten (d.h. mit
+    |C| ≥ k)?
+
+    Beweisen Sie: Das Problem k-C LIQUE ist NP-vollständig.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«             Seite 6 von 11
+Aufgabe 5 NP UND NP-VOLLSTÄNDIGKEIT (4+4+7 Punkte)
+
+
+    a) Beweisen Sie die NP-Vollständigkeit von S UBSET S UM, bei der jede Itemgröße jeweils durch
+       3 oder durch 7 teilbar ist.
+    b) Beweisen Sie die NP-Vollständigkeit von 3-C OLOR, wobei jeder Knoten im Graph mindes-
+       tens Grad 3 hat.
+    c) Zeigen Sie: Für kein α > 1 gibt es einen approximativen Algorithmus mit Güte α (d.h. mit
+       Zielfunktionswert ≤ α · OPT) für TSP, außer P = NP (Denken Sie an Wiliam Rowan Hamil-
+       ton).
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«               Seite 7 von 11
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 8 von 11
+Aufgabe 6 U NTERE S CHRANKEN UND ETH (7+8 Punkte)
+    Betrachten Sie folgende Reduktionen:
+    Problem: H ITTING S ET
+    Eingabe: Eine Menge U sowie r Teilmengen F1 , . . . , Fr ⊆ U und eine Zahl k.
+    Entscheide: Gibt es eine Menge S ⊆ U mit |S| ≤ k und S ∩ Fi ̸= 0/ für alle i ∈ [r]?
+
+    a) 3-SAT ⪯ H ITTING S ET: Seien v1 , . . . , vn die Variablen der Formel und C1 , . . . ,Cm die Klau-
+       seln. Setze U = { v1 , v1 , . . . , vn , vn } und k = n. Für jede Variable vi definiere eine Menge
+       Fi = {vi , vi } und für jede Klausel C j definiere eine Menge Fn+ j = C j
+       Welche unteren Schranken ergeben sich durch obige Reduktion für die Laufzeit von Algorith-
+       men für H ITTING S ET unter Annahme der ETH in Abhängigkeit von
+         (i) r?
+        (ii) |U|?
+       Beweisen Sie die entsprechenden unteren Schranken!
+       Hinweis: Sie dürfen – wie in den Hausaufgaben zur ETH – Faktoren, die polynomiell in der
+       Eingabekodierung sind, vernachlässigen.
+    b) 3-S AT ⪯ S UBSET S UM: Seien v1 , . . . , vn die Variablen der Formel und C1 , . . . ,Cm die Klauseln.
+       Für jede Variable vi erzeuge zwei Items ai und bi , mit den Größen
+
+                     s(ai ) = 10i−1 + ∑ 10n+ j−1             und    s(bi ) = 10i−1 + ∑ 10n+ j−1 .
+                                       j∈[m]                                       j∈[m]
+                                       xi ∈C j                                     xi ∈C j
+
+       Zusätzlich erzeuge zwei Items c j und d j für jede Klausel C j mit Größen
+
+                                                 s(c j ) = s(d j ) = 10n+ j−1 .
+
+       Der Zielwert sei
+                                      B = ∑ 3 · 10n+ j−1 + ∑ 10i−1 .
+                                                        

+                                             j∈[m]                     i∈[n]
+
+       Welche unteren Schranken ergeben sich durch obige Reduktion für die Laufzeit von Algorith-
+       men für S UBSET S UM unter Annahme der ETH in Abhängigkeit von
+         (i) der Anzahl der unterschiedlichen Itemgrößen d?
+        (ii) der binären Kodierungslänge L der größten Itemgröße ∆ (d.h. L = log(∆))?
+       Beweisen Sie die entsprechenden unteren Schranken!
+       Hinweis: Sie dürfen auch hier – wie in den Hausaufgaben zur ETH – Faktoren, die polynomiell
+       in der Eingabekodierung sind, vernachlässigen.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                           Seite 9 von 11
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 10 von 11
+                                      Viel Erfolg!
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 11 von 11
+                          CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                          Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                          Prof. Dr. K. Jansen
+
+                                                                                       19. Oktober 2023
+
+                     Modulprüfung zur Vorlesung
+     »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«
+                                             SS 2023
+ Name:                                       Matrikel-Nr.:
+
+
+Hinweise:
+
+• Bearbeiten Sie alle Aufgaben.
+• Sie haben 120 Minuten Zeit für die Klausurbearbeitung.
+• Erlaubte Hilfsmittel: Ein einseitig handschriftlich beschriebenes Blatt Papier, (bunte) Stifte (kein Rot,
+  kein Grün, kein Bleistift, kein Tintenkiller, kein Tipp-Ex).
+• Schreiben Sie auf jedes Blatt ihren Namen.
+• Wenn Sie Schmierzettel verwenden um eine Aufgabe zu bearbeiten, verweisen Sie in der Aufgabe auf
+  diese.
+• Einsichtnahme: 2.11.23, 13:30-14:30 Uhr.
+• Die Klausur hat 6 Aufgaben auf 13 Seiten – überprüfen Sie bitte vor der Bearbeitung, dass Ihre Klausur
+  vollständig ist.
+Aufgabe 1 C HRISTOFIDES ’ A LGORITHMUS (3+7 Punkte)
+    Gegeben sei folgender Graph G = (V, E) :
+
+                                                d
+
+                                          2
+                                                       3
+
+                                                3
+                                      a                    c
+
+
+                                          1
+                                                       2
+
+                                                b
+
+    a) Geben Sie an, was Christofides’ Algorithmus berechnet, und welche approximative Güte er
+       hat. Welche Eigenschaft müssen die Distanzen neben der Symmetrie noch erfüllen, damit
+       Christofides’ Algorithmus korrekt arbeitet.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«            Seite 1 von 19
+    b) Wenden Sie den Algorithmus von Christofides auf den Graphen G mit Startknoten a an. Ge-
+       ben Sie dabei alle Graphen an, die in Zwischenschritten entstehen. Erwähnen Sie ebenfalls
+       Schritte, die bei dieser Anwendung zu keiner Änderung führen, die der Algorithmus aber
+       überprüfen muss.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«              Seite 2 von 19
+Aufgabe 2 D OMINATING S ET (3+3+4 Punkte)
+    Betrachten Sie das folgende Problem:
+    Problem: D OMINATING S ET
+    Eingabe: Ein ungerichteter Graph G = (V, E) (wobei V = {1, . . . , n} für eine Zahl n ∈ N≥1 )
+    und eine Zahl k ∈ N0 .
+    Entscheide: Gibt es eine Teilmenge D ⊆ V der Knoten mit |D| ≤ k, sodass jeder Knoten v ∈ V
+    in D enthalten ist oder benachbart zu mindestens einem der Knoten in D ist?
+
+    Zeigen Sie auf verschiedene Weisen, dass das Problem in NP liegt:
+    a) Geben Sie ein Zertifikat für D OMINATING S ET an.
+    b) Beschreiben Sie einen polynomiellen Verifizierer für D OMINATING S ET und schätzen Sie die
+       Laufzeit in O-Notation konkret ab.
+    c) Beschreiben Sie (in Worten) eine polynomielle, nicht-deterministische Turing-Maschine, die
+       D OMINATING S ET löst. Schätzen Sie auch hier die Laufzeit in O-Notation konkret ab.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«               Seite 3 von 19
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 4 von 19
+Aufgabe 3 A PPROXIMATIVE A LGORITHMEN (6+4 Punkte)
+    Das Problem M IN -E DGE -C OVER sei folgendermaßen definiert:
+    Problem: M IN -E DGE -C OVER
+    Eingabe: Ein zusammenhängender, ungerichteter Graph G = (V, E).
+    Ausgabe: Eine Teilmenge der Kanten C ⊆ E mit minimaler Kardinalität, sodass jeder Knoten
+    v ∈ V zu mindestens einer Kante aus C inzident ist.
+
+    Betrachten Sie folgenden Algorithmus A:
+
+       • Gehe (in beliebiger Reihenfolge) alle Knoten durch:
+       • Falls der aktuelle Knoten v noch nicht abgedeckt ist, wähle zufällig eine der zu v inzidenten
+         Kanten und füge sie zu C hinzu.
+       • Gib anschließend die entstehende Menge C zurück.
+
+    a) Zeigen Sie, dass obiger Algorithmus Güte 2 hat, d.h. A(G) ≤ 2 · OPT(G) gilt für alle Eingaben
+    G.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                   Seite 5 von 19
+    b) Sei n ∈ N≥4 gerade. Betrachten Sie den Graphen Gn , der genau n Knoten und n Kanten hat und
+    einen Kreis beschreibt. D.h. Gn = ({1, . . . , n}, {{i, i+1} | i ∈ {1, . . . , n−1}}∪{{n, 1}}). Wie viele
+    Kanten hat ein M IN -E DGE -C OVER des Graphen Gn ? Wie schlecht ist die Approximationsrate
+    des Algorithmus A für Gn im schlimmsten Fall? Geben Sie eine Reihenfolge der Knoten (für
+    Schritt 1) und eine Auswahl der Kanten (für Schritt 2) an, die zu einer möglichst schlechten
+    Approximationsrate führen.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                         Seite 6 von 19
+Aufgabe 4 B EWEIS – S CHEDULING AUF IDENTISCHEN M ASCHINEN (10 Punkte)
+    Betrachten Sie das Scheduling-Problem P||Cmax :
+    Problem: P||Cmax
+    Eingabe: Eine Liste L = (J1 , . . . , Jn ) von n Jobs mit Ausführungszeiten p1 , . . . , pn ∈ N, und m
+    identische Maschinen.
+    Ausgabe: Ein Schedule (Partition von J in m Teilmengen B1 , . . . , Bm ) mit minimaler maximaler
+    Last Cmax := max ∑ p j .
+                  1≤i≤m J ∈B
+                          j   i
+
+
+    Betrachten Sie den folgenden Algorithmus ListScheduling, der einen Schedule berechnet. Sei
+    LS(I) die Last Cmax eines Schedules des Algorithmus, und OPT(I) die Last Cmax eines optimalen
+    Schedules zur Eingabe I. Zeigen Sie: Für alle Eingaben I = (L, m) gilt LS(I)/OPT(I) ≤ 2 − 1/m.
+
+    Algorithmus L IST S CHEDULING(L = (J1 , . . . , Jn ), m)
+
+      1   for i = 1 to m do
+      2     Ei = 0; Bi = 0/ ;
+      3   od
+      4   for j = 1 to n do
+      5     wähle Job J j aus Liste L;
+      6     wähle Maschine Mi mit minimaler Last Ei ;
+      7     Bi = Bi ∪ {J j };
+      8     Ei = Ei + p j ;
+      9   od
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                       Seite 7 von 19
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 8 von 19
+Aufgabe 5 NP UND NP-VOLLSTÄNDIGKEIT (4+5+6 Punkte)
+
+    Problem: H AMILTONIAN PATH
+    Eingabe: Ein ungerichteter Graph G = (V, E)
+    Entscheide: Existiert ein Pfad in G, der jeden Knoten genau einmal besucht?
+    Problem: H AMILTONIAN C YCLE
+    Eingabe: Ein ungerichteter Graph G = (V, E)
+    Entscheide: Existiert ein Kreis in G, der jeden Knoten genau einmal besucht?
+
+    (a) Sei L ⊆ S UBSET S UM die Menge der (positiven) SubsetSum-Instanzen, bei denen keine der
+        Itemgrößen eine Zweierpotenz ist. Zeigen Sie, dass L NP-vollständig ist.
+    (b) Geben Sie eine polynomielle Reduktion von H AMILTONIAN PATH auf H AMILTONIAN C Y-
+        CLE an.
+
+    (c) Geben Sie eine polynomielle Reduktion von H AMILTONIAN C YCLE auf H AMILTONIAN -
+        PATH an.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«               Seite 9 von 19
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 10 von 19
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«   Seite 11 von 19
+Aufgabe 6 U NTERE S CHRANKEN UND ETH (5+5 Punkte)
+    Im Folgenden bezeichne ⟨I⟩ die Kodierungslänge der Instanz.
+    (a) Wir betrachten folgendes Problem:
+        Problem: H ITTING S ET
+        Eingabe: Eine Menge U ′ sowie r′ Teilmengen F1′ , . . . , Fr′′ ⊆ U ′ und eine Zahl k′ .
+        Entscheide: Gibt es eine Menge S′ ⊆ U ′ mit |S′ | ≤ k′ und S′ ∩ Fi′ ̸= 0/ für alle i′ ∈ {1, . . . , r′ }?
+
+        Sie dürfen nutzen, dass sich H ITTING S ET unter Annahme der ETH nicht in Zeit 2o(r ) ⟨I⟩O(1)
+                                                                                                        ′
+
+
+        und nicht in Zeit 2o(|U |) ⟨I⟩O(1) lösen lässt.
+                               ′
+
+
+         Problem: S ET C OVER
+         Eingabe: Eine Menge U sowie r Teilmengen F1 , . . . , Fr ⊆ U und eine Zahl k.
+         Entscheide: Gibt es eine Menge S ⊆ {1, . . . , r} mit |S| ≤ k und i∈S Fi = U?
+                                                                          S
+
+
+        Welche unteren Schranken ergeben sich
+          (i) in Hinblick auf |U| sowie
+         (ii) in Hinblick auf r
+        für S ET C OVER unter Annahme der ETH aus den unteren Schranken für H ITTING S ET, wenn
+        man folgende Reduktion von SetCover auf HittingSet verwendet?
+        Sei (F ,U, k) eine S ET C OVER-Instanz. Setze V1 := U und V2 := {1, . . . , r}. Sei V := V1 ∪V˙ 2.
+        Weiter sei E = { {v, w} | v ∈ V1 , w ∈ V2 , v ∈ Fw }. Damit ist G = (V, E) ein bipartiter Graph
+        mit Partitionen V1 ,V2 . Setze U ′ := {1, . . . , r}. Erzeuge nun eine Menge Fw′ für jeden Knoten
+        w ∈ V1 , indem Fw′ := { v ∈ V2 | {v, w} ∈ E } gesetzt wird. Sei F ′ := { Fw′ | w ∈ V1 }. Mit k′ = k
+        iie berechnete Instanz ist nun durch (F ′ ,U ′ , k′ ) gegeben.
+
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                            Seite 12 von 19
+    (b) Wir wollen uns mit einem Problem beschäftigen, das ein mächtiges Werkzeug im Bereich
+        der Optimierung ist: Integrale Lineare Programme (ILPs).
+         Problem: ILP-F EASIBILITY
+         Eingabe: Eine Matrix A ∈ ZM×N , eine rechte Seite b ∈ ZM .
+         Entscheide: Gibt es einen Vektor x ∈ ZN≥0 mit Ax ≤ b, d.h. Ai xi ≤ bi für alle i ∈ {1, . . . , M}?
+        Welche unteren Schranken ergeben sich
+          (i) in Hinblick auf M sowie
+         (ii) im Hinblick auf N
+        für ILP-F EASIBILITY unter Annahme der ETH, wenn man folgende Reduktion von 3-SAT
+        auf ILP-F EASIBILITY verwendet?
+        Sei φ eine 3-SAT Instanz mit m Klauseln (Ci )i∈m und n Variablen. Analog zu linearen Glei-
+        chungssystemen (Ax = b), die aus M Gleichungen bestehen, haben wir bei Ax ≤ b einen
+        Satz von M linearen Ungleichungen. Wir konstruieren diese wie folgt: Wir nutzen N := 2n
+        Variablen in unserem ILP, eine für jedes (mögliche) Literal in der SAT-Formel. Für je-
+        de SAT-Variable v sei xv die ILP-Variable, die zum SAT-Literal v korrespondiert, und xv̄
+        die, die zum SAT-Literal v̄ korrespondiert. Für jede Klausel Ci erzeugen wir eine Unglei-
+        chung − ∑ℓ∈Ci xℓ ≤ −1. Weiter erzeugen wir für jede SAT-Variable v zwei Ungleichungen:
+        xv +xv̄ ≤ 1 und −xv −xv̄ ≤ −1. Durch das Eintragen der entsprechenden Koeffizienten in eine
+        erweiterte Koeffizientenmatrix (bestehend aus Matrix A und rechter Seite b) erhalten wir die
+        ILP-F EASIBILITY Instanz.
+
+
+
+
+                                           Viel Erfolg!
+
+
+
+Klausur »Analyse von Algorithmen und Komplexität (Komplexitätsteil)«                      Seite 13 von 19
+

uni/aak/alle_praesenzaufgaben.txt

@@ -0,0 +1,480 @@
+                          CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                          Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                          Prof. Dr. K. Jansen, B. Schumacher, C. Wambsganz
+
+                                                                                    09.06.2025
+
+        Präsenzaufgaben zur Vorlesung »Analyse von Algorithmen und
+                               Komplexität«
+                                              Blatt 9
+
+
+Definition 1 (Knapsack (Entscheidungsvariante)). Gegeben ist eine Menge mit n Gegenständen
+mit Gewichten w1 , . . . , wn ∈ N≥0 und Profiten p1 , . . . , pn ∈ N≥0 . Weiter sind eine Kapazität
+K ∈ N≥0 und ein Zielprofit P ∈ N≥0 gegeben. Bei dem K NAPSACK Problem muss entschieden
+werden, ob eine Teilmenge S ⊆ [n] existiert, sodass
+
+                                   ∑ wi ≤ K    und      ∑ pi ≥ P
+                                  i∈S                   i∈S
+
+gilt.
+
+Präsenzaufgabe 9.1 (K NAPSACK in NP)
+Zeigen Sie K NAPSACK ∈ NP auf zwei verschiedene Wege.
+   1. Geben Sie einen nicht deterministischen Algorithmus an, der das Problem in polynomi-
+      eller Zeit löst.
+   2. Geben Sie einen polynomiellen Verifizierer für das Problem an.
+Wie hängen diese beiden Methoden zusammen?
+
+Lösung.    1. Der Algorithmus arbeitet wie folgt: Für jeden Gegenstand entscheiden wir nicht-
+     deterministisch, ob er in den Rucksack soll. Anschließend akzeptieren wir, falls die Kapazitäts-
+     und Profitbedingung erfüllt sind.
+        Existiert eine valide Rucksackfüllung mit genügend Profit, dann gibt es auch eine Reihe
+        von nichtdeterministischen Entscheidungen, die diese Füllung findet. Diese wird dann
+        auch vom Algorithmus akzeptiert.
+        Der Algorithmus macht polynomiell viele nichtdeterministische Entscheidungen und die
+        Überprüfung der Eigenschaften ist ebenfalls in Polynomialzeit möglich, also ist dies ein
+        polynomieller, nichtdeterministischer Algorithmus, der K NAPSACK löst.
+   2. Unser Zertifikat ist eine Teilmenge S ⊆ [n], die die Auswahl für den Rucksack darstellen
+      soll. Dies kann zum Beispiel über ein Bit pro Gegenstand realisiert werden. Um dieses
+      Zertifikat zu verifizieren, berechnen wir ∑i∈S wi und ∑i∈S pi und vergleichen die Werte
+      mit K und P und akzeptieren entsprechend.
+        Existiert eine valide Rucksackfüllung mit genügend Profit, dann gibt es auch ein Zertifi-
+        kat, das diese Füllung beschreibt. Dieses wird dann auch vom Verifizierer akzeptiert.
+        Das Ausrechnen der Summen und das Überprüfen ist in polynomieller Zeit möglich, also
+        ist dies ein polynomieller Verifizierer.
+In beiden Wegen wird die extra Ressource, die wir zur Verfügung haben, genutzt, um eine
+Teilmenge (einen möglichen Rucksack) zu bestimmen und zu überprüfen. In der Vorlesung
+wird noch genau gezeigt, dass diese beiden Wege tatsächlich äquivalent sind.
+
+Präsenzaufgabe 9.2 (Transitivität von Polynomialzeitreduktionen)
+Zeigen Sie, dass Polynomialzeitreduktionen transitiv sind, d.h., dass für alle Entscheidungspro-
+bleme L1 , L2 , L3 ⊆ Σ∗ gilt, dass
+
+                               L1 ⪯ L2 ∧ L2 ⪯ L3 =⇒ L1 ⪯ L3 .
+
+Lösung. Seien L1 , L2 , L3 Sprachen. Zudem sei R1 ein Algorithmus, der L1 nach L2 in O(na )
+reduziert, und R2 ein Algorithmus, der L2 nach L3 in O(nb ) reduziert.
+Sei x eine Instanz von L1 der Größe n. Dann benötigt der Aufruf von R1 auf x höchstens O(na )
+Zeit.
+Sei x′ die Ausgabe von R1 . Dann hat x′ eine Größe von höchstens O(na ). Diese Schranke für
+die Ausgabe ergibt sich aus der Laufzeit der Reduktion. Der Aufruf von R2 auf x′ benötigt nun
+höchstens O((na )b ) = O(nab ) Zeit. Damit ist die Reduktion von L1 auf L3 in polynomieller Zeit
+möglich.
+Die Korrektheit ergibt sich aus der Transitivität der Äquivalenz: Sei x′′ die Ausgabe von R2 auf
+x′ , dann gilt
+                        x ∈ L1 ⇐⇒ x′ ∈ L2 und x′ ∈ L2 ⇐⇒ x′′ ∈ L3 ,
+also auch x ∈ L1 ⇐⇒ x′′ ∈ L3 .
+                        CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                        Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                        Prof. Dr. K. Jansen, B. Schumacher, C. Wambsganz
+
+                                                                                  16.06.2025
+
+      Präsenzaufgaben zur Vorlesung »Analyse von Algorithmen und
+                             Komplexität«
+                                           Blatt 10
+
+
+Präsenzaufgabe 10.1 (Fragen über Fragen)
+Diskutieren Sie die folgenden Aussagen (Gelten sie allgemein? Gelten sie nicht? Gelten sie
+unter bestimmten Bedingungen? Welche?):
+ (i) Für jede Sprache, die von einer NDTM in polynomieller Zeit akzeptiert werden kann,
+     existiert eine DTM, die ebenfalls die Sprache in polynomieller Zeit akzeptiert.
+ (ii) A ist NP-schwer =⇒ A ∈ P
+
+Lösung. (i) Die Aussage gilt nur, wenn P = NP. Dann liegen alle Probleme in NP (von
+    NDTM in polynomieller Zeit lösbar) auch in P (von DTM in polynomieller Zeit lösbar).
+    Falls P ̸= NP, dann nein, weil sonst folgender Widerspruch auftritt: ein Problem in NP \ P
+    ist von einer NDTM, nicht aber von einer DTM in polynomieller Zeit lösbar. Könnte eine
+    DTM die NDTM in polynomieller Zeit simulieren, wäre das Problem auch in P.
+ (ii) Falsch. Es gibt NP-schwere Probleme, die nicht in NP liegen, z.B. das H ALTE-Problem.
+      Diese liegen folglich auch definitiv nicht in P. NP-schwer ist eine untere Schranke, ∈ NP
+      eine obere, und wenn beide erfüllt sind, ist ein Problem NP-vollständig.
+
+
+
+Definition 1 (Vertex Cover (VC)). Für einen (ungerichteten) Graphen G = (V, E) ist ein Vertex
+Cover eine Menge von Knoten C ⊆ V , sodass u ∈ C oder v ∈ C für alle { u, v } ∈ E gilt, also ist
+für alle Kanten mindestens ein Endpunkt in C.
+Für das V ERTEX C OVER Problem ist neben einem Graphen G eine Zahl k ∈ N≥0 gegeben und
+es wird gefragt, ob ein Vertex Cover mit Größe (Anzahl der Knoten) höchstens k in G existiert.
+
+Präsenzaufgabe 10.2 (V ERTEX C OVER ist NP-vollständig)
+Zeigen Sie, dass V ERTEX C OVER NP-vollständig ist.
+Hinweis: Reduzieren Sie C LIQUE auf V ERTEX C OVER.
+
+Lösung. V ERTEX C OVER ∈ NP ist bekannt aus der letzten Hausaufgabe.
+Vorüberlegung zur Reduktion von C LIQUE auf V ERTEX C OVER: Sei eine Instanz mit G =
+(V, E) und k ∈ N≥0 von C LIQUE gegeben. Wir invertieren zunächst den Graphen G und erhal-
+ten damit G′ . Nun enthält G′ genau dann eine unabhängige Menge der Größe ℓ, wenn G eine
+Clique der Größe ℓ enthält. Wenn ein Graph mit n Knoten eine unabhängige Menge mit min-
+destens k Knoten hat, dann hat der Graph auch ein Vertex Cover mit maximal n − k Knoten
+(das Komplement zur unabhängigen Menge). Unsere Instanz für V ERTEX C OVER ist also G′
+und n − k. (k ≤ n können wir annehmen)
+Betrachte nun folgende Reduktion:
+Sei eine Instanz mit G = (V, E) und k ∈ N≥0 von C LIQUE gegeben. Invertiere den Graphen G
+und erhalte damit G′ . Gebe nun G′ und n − k als Instanz von V ERTEX C OVER zurück.
+Korrektheit:
+⇒ (Falls (G, k) eine Ja-Instanz von C LIQUE ist, dann ist (G′ , n − k) eine Ja-Instanz von V ER -
+TEX C OVER .):
+
+G enthalte eine Clique C der Größe ≥ k. Dann ist V ′ := V \C ein Vertex Cover von G′ der Größe
+≤ n − k. Da |C| ≥ k, gilt |V ′ | ≤ n − k. Da C eine Clique ist, also alle Knoten aus C mit allen
+anderen Knoten aus C verbunden sind, gibt es im invertierten Graphen G′ keine Kante zwischen
+Knoten aus C. Also gilt für jede Kante {u, v} ∈ E ′ , dass u ∈          / C und somit u ∈ V ′ oder
+                                                             / C oder v ∈
+v ∈ V ′.
+⇐ (Falls (G′ , n − k) eine Ja-Instanz von V ERTEX C OVER ist, dann ist (G, k) eine Ja-Instanz von
+C LIQUE.):
+G′ enthalte ein Vertex Cover V ′ der Größe ≤ n−k. Dann ist C := V \V ′ eine Clique der Größe ≥
+k in G. Da |V ′ | ≤ n − k, gilt |C| ≥ k. Für jede Menge {u, v} ⊆ C gilt, dass {u, v} ∈
+                                                                                     / E ′ . Ansonsten
+wäre V ′ kein korrektes Vertex Cover. Da G′ der invertierte Graph von G ist, gilt somit {u, v} ∈ E
+für jede Menge {u, v} ⊆ C.
+Laufzeit: Das Invertieren des Graphen kann naiv in O(|V |2 · |E|) Zeit, also in polynomieller
+Zeit, erledigt werden.
+Also existiert eine polynomielle Reduktion von C LIQUE auf V ERTEX C OVER. Da C LIQUE
+NP-vollständig ist und V ERTEX C OVER ∈ NP gilt, ist somit V ERTEX C OVER NP-vollständig.
+
+
+Präsenzaufgabe 10.3 (Turingmaschinen)
+                                                             n
+Entwerfen Sie eine Turingmaschine für die Sprache L = { 02 | n ∈ N } über dem Alphabet
+Σ = {0} und geben Sie die Laufzeit Ihrer Turingmaschine an. Begründen Sie die Korrektheit
+und die Laufzeit Ihrer Turingmaschine. Diskutieren Sie die Laufzeit Ihrer Turingmaschine im
+Vergleich zu einem Algorithmus (mit RAM) für diese Sprache.
+
+Lösung. Die Turingmaschine sieht folgendermaßen aus:
+  (1) Falls genau eine 0 auf dem Band steht, akzeptiere.
+  (2) Bewege den Kopf von links nach rechts über die Eingabe und ersetze jede zweite 0 durch
+      ein neues Symbol x.
+  (3) Falls das letzte Symbol der Eingabe nun eine 0 ist, verwerfe.
+  (4) Gehe zu Schritt (1).
+Korrektheit: Die Sprache L besteht aus allen Wörtern, die nur Nullen enthalten und deren Länge
+eine Zweierpotenz ist. Eine Zahl ist genau dann eine Zweierpotenz, wenn sie nach wiederholtem
+Teilen durch 2 irgendwann eine 1 ergibt. Genau das überprüft die Turingmaschine. Wenn bei
+diesem wiederholten Teilen eine ungerade Zahl auftritt, ist die Zahl keine Zweierpotenz. In
+diesem Fall verwirft die Turingmaschine die Eingabe (siehe Schritt (3)).
+Laufzeit: Die angegebene Turingmaschine hat eine Laufzeit von O(n log(n)), wobei n hier die
+Länge der Eingabe bezeichnet. Schritt (1) und Schritt (2) benötigen jeweils eine Laufzeit von
+O(n). Schritt (3) geht in konstanter Laufzeit O(1). Schritt (4) wiederholt die Schritte (1) bis (3)
+bis nur noch eine 0 auf dem Band steht oder vorher abgebrochen wird. Da in jedem Durchlauf
+der Schritte (1) bis (3) die Hälfte der Nullen (abgerundet) durch x Symbole ersetzt wird, steht
+nach log n Durchläufen nur noch eine Null auf dem Band und es wird nach Schritt (1) akzeptiert
+oder es steht nach ⌊log n⌋ − 1 Durchläufen eine ungerade Anzahl von Nullen auf dem Band und
+es wird nach Schritt (3) verworfen. Also gibt es maximal log n + 1 Durchläufe.
+Diskussion: Ein Algorithmus mit RAM könnte folgendermaßen aussehen:
+   1. Zähle die Buchstaben und erhalte Anzahl m.
+   2. Falls log m ganzzahlig ist, akzeptiere. Sonst verwerfe.
+Dieser Algorithmus hat eine Laufzeit von O(n), wobei n hier die Länge der Eingabe bezeichnet.
+Ein Algorithmus mit RAM kann also den zusätzlichen Speicher nutzen, um wesentlich schneller
+eine Aufgabe zu erledigen, im Vergleich zu einem Algorithmus, der auf einer Turingmaschine
+läuft.
+                        CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                        Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                        Prof. Dr. K. Jansen, B. Schumacher, C. Wambsganz
+
+                                                                                23.06.2025
+
+      Präsenzaufgaben zur Vorlesung »Analyse von Algorithmen und
+                             Komplexität«
+                                          Blatt 11
+
+
+Präsenzaufgabe 11.1 (Fragen über Fragen)
+Diskutieren Sie nachfolgende Aussagen. Sind diese wahr oder falsch?
+(a) Für L ∈ NP gilt, aus L ⪯ 3-SAT folgt, dass L NP-vollständig ist.
+(b) Gilt für eine Sprache L, dass sowohl L ⪯ 3-SAT als auch 3-SAT ⪯ L, dann ist L NP-vollständig.
+(c) Sei L NP-vollständig. Dann gilt L ∈ P genau dann, wenn P = NP.
+(d) Es ist möglich, dass 3-SAT ∈ P und C LIQUE ∈
+                                               / P.
+
+Lösung.
+                                    / Offensichtlich gilt L ∈ NP. Aus L ⪯ 3-SAT folgt nur,
+(a) Nein, ein Gegenbeispiel ist L = 0.
+    dass sich L auf 3-SAT reduzieren lässt, nicht anders herum.
+(b) Das ist die Definition von NP-vollständig.
+(c) Korrekt, da sich jedes Problem auf L reduzieren lässt nach Def. NP-vollständig (und offen-
+    sichtlich P ⊆ NP).
+(d) Nein, weil 3-SAT NP-vollständig ist, lässt sich C LIQUE (liegt bekannterweise in NP, ist
+    sogar NP-vollständig) auf 3-SAT reduzieren.
+
+
+
+Präsenzaufgabe 11.2 (NP-Vollständigkeit)
+In dem Problem C LIQUE -N OMEMBER ist ein Graph G = (V, E), ein Knoten v ∈ V sowie eine
+Zahl k ∈ N gegeben und es soll entschieden werden, ob es eine Clique mit k Knoten gibt, die
+den Knoten v nicht enthält.
+Zeigen Sie, dass C LIQUE -N OMEMBER NP-vollständig ist, indem Sie eine Reduktion von C LI -
+QUE auf C LIQUE -N OMEMBER angeben. Sie können davon ausgehen, dass C LIQUE -N OMEMBER ∈
+NP ist.
+
+Lösung. Clique-Nomember ist NP-schwer:
+Sei (G = (V, E), k) eine Eingabe für das Clique Problem.
+Idee: Füge einen neuen isolierten Knoten v zu G hinzu.
+Wir geben zuerst die Abbildung an: Sei v ̸∈ V . Wir definieren die Eingabe für das Problem
+C LIQUE -N OMEMBER als den Graphen G′ := (V ∪ {v}, E), den Knoten v als Knoten, der nicht
+benutzt werden darf, und k als gesuchte Cliquengröße. (G′ , v, k) ist eine gültige Eingabe für
+C LIQUE -N OMEMBER und in polynomieller Zeit berechenbar.
+Wir zeigen nun: G hat eine k-Clique genau dann, wenn G′ eine k-Clique ohne v beinhaltet.
+⇒:
+Sei (G, k) eine Ja-Instanz des C LIQUE Problems. Dann enthält G eine k-Clique C. Dann ist C
+auch eine k-Clique in G′ , da bei der Abbildung keine Kanten entfernt wurden. Da v ̸∈ V , enthält
+C den Knoten v nicht. Damit ist C eine k-Clique in G ohne den Knoten v. (G′ , v, k) ist also eine
+Ja-Instanz des C LIQUE -N OMEMBER Problems.
+⇐:
+Sei (G′ , v, k) eine Ja-Instanz des C LIQUE -N OMEMBER Problems. Dann enthält G′ eine k-Clique
+C mit v ̸∈ C. Da bei der Abbildung an dem Graphen nichts geändert wurde, außer der Knoten v
+hinzugefügt, muss C auch eine k-Clique in G sein. Damit ist (G, k) eine Ja-Instanz des C LIQUE
+Problems.
+Also existiert eine polynomielle Reduktion von C LIQUE auf C LIQUE -N OMEMBER. Da C LI -
+QUE NP-vollständig ist und C LIQUE -N OMEMBER ∈ NP nach Aufgabenstellung gilt, ist somit
+C LIQUE -N OMEMBER NP-vollständig.
+
+
+
+Präsenzaufgabe 11.3 (NP-Vollständigkeit)
+Für das Problem S UBSET S UM C ARDINALITY seien n ganze Zahlen c1 , . . . , cn ∈ N>0 (wobei n
+gerade sei) sowie eine Zahl K ∈ N gegeben. Es soll entschieden werden, ob es eine Teilmenge
+S ⊂ {1, . . . , n} gibt mit |S| = n/2 und ∑i∈S ci = K.
+Zeigen Sie, dass das Problem S UBSET S UM C ARDINALITY NP-vollständig ist. Sie können
+davon ausgehen, dass S UBSET S UM C ARDINALITY ∈ NP ist.
+
+Lösung. Subset Sum Cardinality ist NP-schwer:
+S UBSET S UM Problem: Gegeben: n ganze Zahlen c1 , . . . , cn ∈ N>0 und Zahl K ∈ N. Frage: Gibt
+es eine Teilmenge S ⊆ {0, . . . , n} mit ∑i∈S ci = K?
+Reduktion: Sei I = (c1 , . . . , cn , K) eine Eingabe für das S UBSET S UM Problem. Definiere c′i :=
+ci + 1 für i ≤ n und c′i := 1 für i ∈ {n + 1, . . . , 2n}. Wir definieren die Eingabe für das Problem
+S UBSET S UM C ARDINALITY als I ′ = (c′1 , . . . , c′2n , K + n).
+Wir zeigen nun: Es gibt eine Lösung für I genau dann, wenn es eine Lösung für I ′ gibt.
+⇒:
+Sei I eine Ja-Instanz des S UBSET S UM Problems. Dann gibt es eine Menge S ⊆ {1, . . . , n} mit
+∑i∈S ci = K. Es gilt also ∑i∈S c′i = ∑i∈S (ci + 1) = K + |S|. Sei nun S′ = {n + 1, . . . , 2n − |S|}. Es
+gilt |S ∪ S′ | = n und ∑i∈S∪S′ c′i = ∑i∈S c′i + ∑i∈S′ c′i = ∑i∈S (ci + 1) + ∑i∈S′ 1 = K + |S| + (n − |S|) =
+K + n. S ∪ S′ ist also eine Lösung für I ′ und I ′ damit eine Ja-Instanz.
+⇐:
+Es sei I ′ eine Ja-Instanz. Dann gibt es also eine Menge S′ ⊆ {1, . . . , 2n} mit ∑i∈S′ c′i = K + n und
+|S′ | = n. Sei S := S′ ∩{1, . . . , n}. Es gilt ∑i∈S′ c′i − ∑i∈S c′i = n−|S|, da die Items in {n+1, . . . , 2n}
+das Gewicht 1 haben, und genau n − |S| Items übrig sind. Damit gilt ∑i∈S (ci + 1) = ∑i∈S c′i =
+K + n − (n − |S|) = K + |S|, woraus folgt, dass ∑i∈S ci = K. Damit ist S eine Lösung für I und
+somit I eine Ja-Instanz.
+Laufzeit: Die Reduktion kann naiv in einer Zeit von O(n) implementiert werden. Das ist eine
+polynomielle Laufzeit.
+Also existiert eine polynomielle Reduktion von S UBSET S UM auf S UBSET S UM C ARDINALI -
+TY . Da nach Skript S UBSET S UM NP-vollständig ist und S UBSET S UM C ARDINALITY ∈ NP
+nach Aufgabenstellung gilt, ist somit S UBSET S UM C ARDINALITY NP-vollständig.
+                         CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                         Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                         Prof. Dr. K. Jansen, B. Schumacher, C. Wambsganz
+
+                                                                                  30.06.2025
+
+      Präsenzaufgaben zur Vorlesung »Analyse von Algorithmen und
+                             Komplexität«
+                                           Blatt 12
+
+
+Präsenzaufgabe 12.1
+Im Folgenden sollen Sie herausfinden (und begründen), welche Lower Bounds sich über ETH
+und die Reduktionen aus der Vorlesung ergeben. Nutzen Sie hierfür auch das Sparsification
+Lemma.
+Welche Schranken für die Laufzeit in Abhängigkeit von den natürlichen Parametern (Anzahl
+Knoten, Anzahl Kanten, Anzahl Items, Anzahl unterschiedlicher Items, Anzahl Tripel, Kardi-
+nalität der Grundmenge, Anzahl unterschiedlicher Tripel, Anzahl unterschiedlicher auftretender
+Zahlen, größte auftretende Zahl, . . . ) ergeben sich jeweils aus folgenden (zum Großteil aus der
+Vorlesung bekannten) Reduktionen (Laufzeitfaktoren, die polynomiell in der Eingabekodierung
+sind, dürfen vernachlässigt werden)?
+Schätzen Sie dazu zunächst die verschiedenen Parameter der resultierenden Instanz mithilfe der
+Parameter der eingegebenen Instanz geeignet ab.
+   1. 3-SAT ⪯ k-C LIQUE
+   2. k-C LIQUE ⪯ k-I NDEPENDENT S ET (Problemdefinition für die Antwort nicht relevant; in
+      der Reduktion wird der Graph G = (V, E) auf den Komplementgraph (V, E) abgebildet)
+   3. SAT ⪯ 3-D IMENSIONAL M ATCHING (Hinweis: 3-SAT ⊆ SAT)
+   4. 3-D IMENSIONAL M ATCHING ⪯ 3-E XACT C OVER
+   5. 3-E XACT C OVER ⪯ S UBSET S UM
+
+Lösung. Angenommen ETH gilt. Das Sparsification Lemma impliziert, dass man 3-SAT nicht
+in 2o(m) · |I|O(1) lösen kann.
+
+   1. In der Reduktion werden |V | = O(m) Knoten und |E| = O(m2 ) Kanten erstellt und k = m.
+      Außerdem gilt n ≤ 3m ∈ O(m).
+         • Lower bound bzgl. der Anzahl an Knoten: 2o(|V |) · |I|O(1)
+           Angenommen, es existiert ein Algorithmus, der k-Clique in 2o(|V |) ·|I|O(1) löst. Dann
+           gibt es auch einen Algorithmus, der 3-SAT in 2o(m) · |I|O(1) löst (Reduktion auf k-
+           Clique + k-Cliquen Algorithmus). Nach dem Sparsification Lemma gibt es dies nur,
+           wenn die ETH nicht gilt.
+                                                   √
+      • Lower bound bzgl. der Anzahl an Kanten: 2o( |E|) · |I|O(1)    √
+        Angenommen, es existiert ein Algorithmus, der k-Clique in 2o( |E|) · |I|O(1) löst.
+        Da |E| ∈ O(m2 ), gibt es dann auch einen Algorithmus, der 3-SAT in 2o(m) · |I|O(1)
+        löst (Reduktion auf k-Clique + k-Cliquen Algorithmus). Nach dem Sparsification
+        Lemma gibt es dies nur, wenn die ETH nicht gilt.
+      • Lower bound bzgl. k: 2o(k) · |I|O(1)
+        Angenommen, es existiert ein Algorithmus, der k-Clique in 2o(k) · |I|O(1) löst. Dann
+        gibt es auch einen Algorithmus, der 3-SAT in 2o(m) · |I|O(1) löst (Reduktion auf k-
+        Clique + k-Cliquen Algorithmus). Nach dem Sparsification Lemma gibt es dies nur,
+        wenn die ETH nicht gilt.
+2. In der Reduktion werden genau |V | Knoten und maximal |E| = O(|V |2 ) Kanten erstellt.
+      • Lower bound bzgl. der Anzahl an Knoten: 2o(|V |) · |I|O(1)
+        Angenommen, es existiert ein Algorithmus, der k-Independent-Set in 2o(|V |) · |I|O(1)
+        löst. Dann gibt es auch einen Algorithmus, der k-Clique in 2o(|V |) · |I|O(1) löst (Re-
+        duktion auf k-Independent-Set + k-Independent-Set Algorithmus). Nach Aufgaben-
+        teil 1, gibt es diesen nur, wenn die ETH nicht gilt.
+                                                       √
+                                                     o( |E|)
+      • Lower bound bzgl. der Anzahl an Kanten: 2            · |I|O(1)            √
+        Angenommen, es existiert ein Algorithmus, der k-Independen-Set in 2o( |E|) ·|I|O(1)
+        löst. Da |E| ≤ |V |2 , gibt es dann auch einen Algorithmus, der k-Clique in 2o(|V |) ·
+        |I|O(1) löst (Reduktion auf k-Independent-Set + k-Independent-Set Algorithmus).
+        Nach Aufgabenteil 1, gibt es diesen nur, wenn die ETH nicht gilt.
+3. In der Reduktion werden Mengen mit |U| = |V | = |W | = O(mn) Elementen erstellt und
+   |T | = O(m2 n2 ) Tupel. Es gilt n ≤ 3m ∈ O(m) für 3-SAT.
+                                                             √
+       • Lower bound bzgl. der Anzahl an Elementen: 2o( |V |) · |I|O(1)                 √
+         Angenommen, es existiert ein Algorithmus, der 3-Dimensional-Matching in 2o( |V |) ·
+         |I|O(1) löst. Da |V | ∈ O(mn) ≤ O(m2 ), gibt es dann auch einen Algorithmus, der
+         3-SAT in 2o(m) · |I|O(1) löst (Reduktion von SAT auf 3-Dimensional-Matching an-
+         gewandt auf 3-SAT Instanzen + 3-Dimensional-Matching Algorithmus). Nach dem
+         Sparsification Lemma geht dies nur, wenn die ETH nicht gilt.
+                                                           √
+                                                           4
+       • Lower bound bzgl. der Kardinalität von T : 2o( |T |) · |I|O(1)                 √
+                                                                                        4
+         Angenommen, es existiert ein Algorithmus, der 3-Dimensional-Matching in 2o( |T |) ·
+         |I|O(1) löst. Da |T | ∈ O(m2 n2 ) ≤ O(m4 ), gibt es dann auch einen Algorithmus, der
+         3-SAT in 2o(m) · |I|O(1) löst (Reduktion von SAT auf 3-Dimensional-Matching an-
+         gewandt auf 3-SAT Instanzen + 3-Dimensional-Matching Algorithmus). Nach dem
+         Sparsification Lemma geht dies nur, wenn die ETH nicht gilt.
+4. Das 3-dimensionale Matching ist ein Spezialfall vom 3-Exact Cover. Daher gelten die
+   Lower Bounds von 3-dimensionalem Matching auch für 3-Exact Cover. Da |U| = 3m ∈
+   O(|V |), ergibt sich, dass es für 3-Exact Cover unter der ETH keinen Algorithmus         √ mit
+                 √
+               o( m)      O(1)                                                            o( |V |)
+   Laufzeit 2        · |I|     geben kann, da sonst 3-dimensionales Matching in 2                  ·
+   |I|O(1) lösbar wäre. Und da |F| = |T |, √ ergibt sich, dass es für 3-Exact Cover unter der ETH
+                                          o( 4 |F|)
+   keinen Algorithmus
+                    √      mit Laufzeit 2           · |I|O(1) geben kann, da sonst 3-dimensionales
+                     4
+   Matching in 2o( |T |) · |I|O(1) lösbar wäre.
+                                                                         √
+                                                                         4
+5. In der Reduktion wird n = |F| gesetzt. Lower bound bzgl. n: 2o( n)√· |I|O(1)
+                                                                     4
+   Angenommen, es existiert ein Algorithmus, der SubsetSum in 2o( n) · |I|O(1) löst. Dann
+                                                           √
+                                                           4
+                                                           |F|)
+gibt es auch einen Algorithmus, der 3-Exact Cover in 2o(          · |I|O(1) löst. Nach Aufga-
+benteil 4, gibt es diesen nur, wenn die ETH nicht gilt.
+                         CHRISTIAN-ALBRECHTS-UNIVERSITÄT ZU KIEL
+                         Institut für Informatik, Arbeitsgruppe Algorithmen und Komplexität
+                         Prof. Dr. K. Jansen, B. Schumacher, C. Wambsganz
+
+                                                                                07.07.2025
+
+      Präsenzaufgaben zur Vorlesung »Analyse von Algorithmen und
+                             Komplexität«
+                                          Blatt 13
+
+
+Präsenzaufgabe 13.1 (Vertex Cover)
+Ein Vertex Cover in einem Graphen G = (V, E) ist eine Menge von Knoten C ⊆ V , so dass für
+jede Kante {v, w} ∈ E gilt, dass v ∈ C oder w ∈ C. Beim Optimierungsproblem Minimum Vertex
+Cover soll die kardinalitätskleinste Menge C ⊆ V gefunden werden, die ein Vertex Cover von
+G ist.
+Gegeben ist der folgende approximative Algorithmus mit Güte 2 für VertexCover:
+Idee: Wähle eine beliebige Kante. Wenn einer der beiden Endknoten bereits in C ist, verwirf
+diese Kante. Sonst, füge beide Endknoten zur Menge C hinzu. Mache dies für jede Kante.
+
+Algorithmus 2A PPROX CV(G = (V, E))
+
+  1   C = {}
+  2   foreach {u, v} ∈ E do
+  3     if u ̸∈ C and v ̸∈ C then
+  4        C = C ∪ {u, v}
+  5     fi
+  6   od
+  7   return C
+
+Beweisen Sie die Güte.
+
+Lösung. Beweis: Sei C∗ ein minimales Vertex Cover. Wir zeigen |C| ≤ 2|C∗ |.
+Sei A die Menge der Kanten, für die beide Endknoten zu C hinzugefügt wurden. Es gilt |C| =
+2|A|, da beide Knoten jeder ausgewählten Kante zu C hinzugefügt wurden und alle anderen
+Kanten nicht weiter betrachtet werden. Damit folgt auch, dass keine zwei Kanten aus A einen
+Knoten gemeinsam haben können. Sei nun C∗ ein minimales Vertex Cover. C∗ enthält nach
+Definition mindestens einen Knoten jeder Kante, also insbesondere einen Knoten jeder Kante
+aus A. Da keine zwei Kanten aus A vom gleichen Knoten aus C∗ überdeckt werden können, gilt
+|C∗ | ≥ |A|. Es folgt |C| = 2|A| ≤ 2|C∗ |. Die Lösung C von 2ApproxCV ist also maximal doppelt
+so groß wie die optimale Lösung C∗ . Damit berechnet der Algorithmus eine 2-Approximation.
+Präsenzaufgabe 13.2 (TSP)
+In der Vorlesung haben Sie zwei approximative Algorithmen für das TSP-Problem kennen ge-
+lernt. Der erste Algorithmus ∆T SP1 hat eine Approximationsrate von 2, während der zweite
+Algorithmus ∆T SP2 von Christofides eine Approximationsrate von 3/2 besitzt. In dieser Übung
+soll gezeigt werden, dass die zweite Rate scharf ist. D.h., dass es eine Folge von Instanzen gibt,
+auf denen der Algorithmus immer näher an diese Rate heran kommt.
+Wir betrachten den vollständigen Graphen Kn = (V, E) für ein n ∈ N≥6 mit n mod 4 = 2 und
+die nachfolgende Gewichtsfunktion d2 : E → R+ . Zeigen Sie, dass
+  (a) OPT((Kn , d2 )) = n gilt und
+  (b) eine mögliche Ausführung von ∆TSP2 existiert, die auf Eingabe (Kn , d2 ) eine Tour der
+      Länge (n − 1) + n/2 berechnet.
+
+
+                       1            1               1              1
+             1              3              5               7              9             n−1
+
+
+                 1              1               1              1              1               1
+
+                       1            1               1              1
+             2              4              6               8              10              n
+
+
+
+Wir definieren E2 := {{i, i + 2}|i ∈ {1, . . . , n − 2}} ∪ {{2i + 1, 2i + 2}|i ∈ {0, . . . , n/2 − 1}} und
+d2 , so dass alle Kanten aus E2 auf 1 abgebildet werden und alle Kanten aus E \ E2 auf den Wert
+des kürzesten Wegs zwischen diesen Knoten in dem oben abgebildeten Graphen abgebildet
+werden.
+
+Lösung. Wichtig bei dieser Aufgabe ist der folgende Fakt: Bei beiden Algorithmen wird ir-
+gendein MST genommen und dann irgendeine Reihenfolge der Knoten. Typischerweise wird
+diese Reihenfolge durch bestimmte Knoten- oder Kanten-Labels festgelegt (wird zum Beispiel
+der Kruskal-Algorithmus zur Konstruktion des MST genutzt, so werden dort die Kanten nach
+Gewicht sortiert. Kanten gleichen Gewichts müssen also auch noch durch irgendeine Reihen-
+folge festgelegt werden.) Wir gehen also davon aus, dass wir diese Reihenfolge auch wählen
+können. Sollte der Algorithmus also einen “besseren” MST oder eine “bessere” Knotenreihen-
+folge nutzen, passen wir die Labels dementsprechend an.
+Ein möglicher MST ist durch die unten angegebene Zick-Zack-Tour gegeben oder formal durch
+       h [                                                                       i
+  ET =          {{ j, j + 1}, { j + 1, j + 3}, { j + 3, j + 2}, { j + 2, j + 4}}} ∪ {{n − 1, n}}.
+           1≤ j≤n−5
+           j mod 4=1
+
+
+                     1              1               1                              1
+            1               3               5              7             n−3             n−1
+
+
+                1               1               1              1              1               1
+
+                     1              1               1                              1
+            2               4               6              8             n−2              n
+Es gilt d(T ) = n − 1 für die Kosten d(T ) des MST T , da nur Kanten mit Kosten 1 gewählt
+werden und n − 1 Kanten gewählt werden müssen, um den Zusammenhang sicher zu stellen.
+Da jeder Knoten im MST außer 1 und n geraden Grad hat, ist das Matching K sehr simpel,
+nämlich K = {{1, n}}. Die Kosten der Kante {1, n} sind n/2 (der kürzeste Pfad von 1 zu n)
+und somit gilt d(K) = n/2 für die Kosten von K. Die Rundreise R entspricht einfach dem MST
+vereinigt mit der Matchingkante und hat somit Kosten: d(R) = n − 1 + n/2.
+Die optimale Tour würde erst “oben” und dann “unten” entlang laufen, also von Knoten 1 zu
+Knoten 3 gehen, dann zu Knoten 5 und so weiter, bis Knoten n − 1 erreicht wurde. Danach
+folgen Knoten n, n − 2, n − 4 und so weiter. Diese Tour hat offensichtlich Kosten n, da wir n
+Kanten mit Gewicht 1 nutzen. Somit gilt OPT((Kn , d2 )) = n und wir haben eine Rate von
+
+                     ∆T SP2 ((Kn , d2 )) n − 1 + n/2        1
+                                        =            = 3/2 − ≤ 3/2.
+                      OPT((Kn , d2 ))         n             n
+
+Da limn→∞ 3/2 − n1 = 3/2, kommen wir der Rate von 3/2 also beliebig nahe.
+