Differences

This shows you the differences between two versions of the page.

--- aa:lab:12 [2022/01/25 10:56]
dmihai
+++ aa:lab:12 [2026/01/19 12:58] (current)
dmihai
@@ Line 1: / Line 1: @@
-===== Structural Induction =====
+====== Abordări practice pentru probleme NP-Complete ======
-Recall the ADTs defined in the [[aa:lab:11|previous lab]] and lecture (together with their operators):
+Problemele NP-Complete despre care am discutat până acum la curs și la laborator au două trăsături principale:
-  * Binary Tree
-  * List
-  * Nat
-And the following definition of ''reverse'':
+  * nu au soluții eficiente cunoscute
+  * sunt relevante practic
-$math[reverse : List \rightarrow List]
+Trebuie deci să avem o strategie de a le aborda, nu putem să le evităm.
+În acest laborator vom studia o strategie puternică numită //"kernelizare"//.
+Kernelizarea are la bază ideea că backtrackingul este inevitabil; dar în loc să aplicăm backtracking pe întreaga instanță a problemei, putem încerca a priori să //extragem miezul dificil al problemei//.
+Această extragere constă în aplicarea unui algoritm determinist polinomial (deci //eficient//) care să reducă drastic dimensiunea problemei.
+Este similar cu o reducere polinomială; dar în loc să transformăm inputul unei probleme ''A'' într-un input pentru o altă problemă ''B'', îl vom transofrma într-un input mai mic pentru aceeași problemă ''A''.
-$math[reverse(Empty) = Empty]
+==== Vertex Cover ====
-$math[reverse(Cons(x, xs)) = append(reverse(xs), Cons(x, Empty))]
+Vom implementa un algoritm simplu de kernelizare pentru problema Vertex Cover pe graful $ G = (V, E)$ și dimensiunea căutată $ K$, care constă în următorii pași:
+    * căutăm toate nodurile $ v \in V$ cu $ grad(v) > K$ (gradul unui nod este numărul de muchii adiacente nodului). Dacă există un cover de dimensiune $ K$ aceste noduri trebuie să facă parte din el. Putem să le reținem separat, apoi să le ștergem din graf și să decrementăm $ K$ pentru fiecare din ele. Căutăm în continuare un cover mai mic într-un graf mai mic. **Atenție!** După aplicarea acestei reguli, este posibil să o putem aplica din nou pe noul graf și noul $ K$.
-. Prove the following properties are true, using structural induction:
+    * Căutăm toate nodurile $ v \in V$ cu $ grad(v) = 0$; acestea pot fi eliminate
-  * $math[\forall t \in \texttt{Tree}. size(t) = size(mirror(t))]
+    * Dacă graful obținut are mai mult de $ K^2$ (aici e vorba de $ K$-ul obținut prin transformări, nu neapărat $ K$ inițial) muchii, atunci graful nu poate conține un cover de dimensiune $ K$ (pentru că acum fiecare nod are grad maxim $ K$, deci $ K$ noduri pot acoperi maxim $ K \times K$ muchii); putem întoarce direct răspunsul negativ. Altfel, invocăm algoritmul de backtracking naiv pe noua instanță.
-  * $math[\forall t \in \texttt{Tree}. size(t) = length(flatten(t))]
-  * $math[\forall a, b, c \in \texttt{Nat}. add(a, add(b, c)) = add(add(a, b), c)]
-  * $math[\forall l \in \texttt{List}. append(l, Empty) = l]
-  * $math[\forall l1, l2, l3 \in \texttt{List}. append(l1, append(l2, l3)) = append(append(l1, l2), l3))]
-  * $math[\forall l1, l2 \in \texttt{List}. length(append(l1, l2)) = length(append(l2, l1))]
-  * $math[\forall l1, l2 \in \texttt{List}. reverse(append(l1, l2)) = append(reverse(l2), reverse(l1))].
+<note>
+Pentru completitudine, trebuie să considerăm și situația $ K = 0$; în acest caz răspunsul e pozitiv dacă și numai dacă nu există muchii în graf.
+</note>
+<note>
+Ca să păstrăm analogia cu reduceri polinomiale (în care transformarea trebuie neapărat să producă o instanță a problemei și nu direct un răspuns) putem la ultimul pas, în caz că sunt mai mult de $ K^2$ muchii, să aplicăm backtracking naiv pe orice instanță despre care știm că răspunsul e negativ: e.g. întoarcem un graf cu două noduri, muchie între ele și $ K = 0$.
+</note>
+==== Exerciții ====
+. Implementați o soluție prin backtracking naiv pentru problema $ \texttt{VERTEX COVER}$; trebuie ca punctul de intrare să fie o funcție ''solve_vertex_cover(<graph>, <k>)''.
+. Implementați pașii de preprocesare discutați mai sus.
+La final, aplicați funcția ''solve_vetex_cover'' pe graful și numărul obținut.
+. Implementați reducerea $ \texttt{CLIQUE} \le_P \texttt{VERTEX COVER}$; trebuie ca punctul de intrare să fie o funcție ''solve_clique(<graph>, <k>)''.
+După reducerea grafului, aplicați preprocesarea prin kernelizare descrisă la punctul 2.
+Găsiți {{:aa:lab:graph-example.zip|aici}} un exemplu de graf în următorul format:
+  * pe prima linie, o literă ''U'' sau ''D'' indică dacă graful este neorientat (**U**ndirected) sau orientat (**D**irected).
+  * tot pe prima linie, seaparate cu un spațiu sunt numărul de noduri $ N$ și numărul de muchii $ M$
+  * pe următoarele $ M$ linii sunt triplete: ID nod sursă, ID nod destinație, cost muchie (pentru grafuri neorientate, muchiile apar o singură dată, listate la nodul cu ID mai mic)
+  * nodurile sunt indexate de la 0.
+Este un graf complet cu 29 de noduri; are acoperiri doar de 28 și de 29 de noduri.