Tema 1 – Algoritmi Avansat, i

Nicula Ionut, -Cosmin

Grupa 234
I. KNAPSACK

Problema poate fi abordată drept un caz particular al problemei Knapsack

0/1 în care, pentru fiecare obiect, valoarea s, i greutatea sa sunt egale.
Mai exact, dânduni-se s, irul S = {s1 , s2 , ..., sn } s, i un număr K, vom considera
problema drept Knapsack 0/1 unde mult, imea de perechi de forma (value, weight)
este L = {(s, s) | s ∈ S}, fiind nevoie să alegem o submult, ime de obiecte din L
care maximizează suma valorilor fără ca suma greutăt, ilor să depăs, ească K.

a) Folosim algoritmul pseudo-polinomial ca la problema Knapsack 0/1 cla-

sică.
Complexitatea timp este O(n · K), complexitatea spat, iu este O(K).

1 #include <iostream>
2 #include <vector>
3
4 int main()
5 {
6 int N, K;
7 std::cin >> N >> K;
8
9 std::vector<int> nums;
10 for(int i = 0; i < N; ++i)
11 {
12 int x;
13 std::cin >> x;
14 nums.push_back(x);
15 }
16
17 std::vector<int> dp(K + 1, 0);
18 for(int i = 1; i <= N; ++i)
19 {
20 for(int w = K; w >= 0; --w)
21 {
22 if(nums[i - 1] <= w)
23 {
24 dp[w] = std::max(dp[w], nums[i - 1] + dp[w - nums[i - 1]]);
25 }
26 }
27 }
28
29 std::cout << dp[K] << '\n';
30 }

1
 b) Folosim algoritmul polinomial de 1/2-aproximare ca la problema Knapsack
0/1. Se observă că lista de obiecte este deja sortată (indiferent de ordinea
value(x)
numerelor din S), deoarece pentru fiecare obiect x din L, weight(x) = 1.
Complexitatea timp este O(n), complexitatea spat, iu este O(1).

1 #include <iostream>
2 #include <vector>
3
4 int main()
5 {
6 int K;
7 std::cin >> K;
8
9 int S = 0;
10
11 int num;
12 int max_num = -1;
13 while(std::cin >> num)
14 {
15 max_num = std::max(max_num, num);
16
17 if(num <= K)
18 {
19 S += num;
20 K -= num;
21 }
22 }
23
24 std::cout << std::max(S, max_num) << '\n';
25 }

2
Tema 1 – Algoritmi Avansat, i
Nicula Ionut, -Cosmin
Grupa 234
II. LOAD BALANCE

Problema 2
a) S, tim că ALG1 este 2-aproximativ s, i ALG2 este 4-aproximativ, deci:

ALG1 ≤ 2 · OP T
ALG2 ≤ 4 · OP T

Deoarece ALG1 este minim OP T , atunci:

ALG1 ≤ 2 · OP T ≤ 2 · ALG1

Trebuie să arătăm dacă există cu sigurant, ă un input I astfel încât:

ALG2 (I) ≥ 2 · ALG1 (I) (1)

Relat, ia (1) se reduce la:

ALG2 (I) ≥ 2 · ALG1 (I) ≥ 2 · OP T (I)

=⇒ ALG2 (I) ≥ 2 · OP T (I)

As, adar, trebuie să răspundem la întrebarea: există un I astfel încât ALG2 (I) ∈
[2 · OP T (I) , 4 · OP T (I)]?
Răspunsul este nu în mod necesar, deoarece, din datele din enunt, , există
posibilitatea ca ALG2 să fie, de fapt, mai bun decât 2-aproximativ, adică:

∀I, ALG2 (I) < 2 · OP T (I)

As, adar, propozit, ia este falsă.

b)

ALG1 (I) > 2 · ALG2 (I) ⇐⇒ 2 · ALG2 (I) < ALG1 (I) ≤ 2 · OP T (I)
⇐⇒ 2 · ALG2 (I) < 2 · OP T (I)
⇐⇒ ALG2 (I) < OP T (I) (2)

Relat, ia (2) este o contradict, ie, deoarece solut, ia optimă într-o problemă de
minimizare nu poate fi strict mai mare decât o altă solut, ie fezabilă.
As, adar, afirmat, ia că nu există niciun input I a.î. ALG1 (I) > 2 · ALG2 (I)
este adevărată.

Problema 3
Lemă.
 
1 X n 
OP T ≥ max · tj , max {tj | 1 ≤ j ≤ n}
m 
j=1

Lemă. Pentru m < n avem:

OP T ≥ tm + tm+1

1
 Rezolvare:
Fie k indicele mas, inii cu load(k) maxim la finalul planificării activităt, ilor.
Fie q indicele ultimei activităt, i adăugate în mas, ina k.
Fie load′ (i) load-ul mas, inii cu indicele i fix înainte de a adăuga activitatea q
în mas, ina k.
Dacă q ≤ m, atunci ALG = load(k) = tq =⇒ ALG = OP T .
Altfel, daca q > m:

ALG = load(k)
= load′ (k) + tq (3)

tq ≤ tm
tq ≤ tm+1
tm + tm+1
=⇒ tq ≤
2

n
1 X tq
(3) =⇒ load′ (k) + tq ≤ · tj − + tq ≤
m j=1 m
tm + tm+1 tm + tm+1
≤ OP T − + ≤
2m 2
OP T OP T
≤ OP T − + =
2m 2
3m · OP T − OP T
= =
2m
OP T · (3m − 1)
= =
2m
3m − 1
= OP T · (4)
2m

3m − 1 3m 1 3 1
= − = − (5)
2m 2m 2m 2 2m
Din (4) s, i (5) rezultă că factorul de aproximare al algoritmului este 3/2 −
1/(2m).

2
Tema 1 – Algoritmi Avansat, i
Nicula Ionut, -Cosmin
Grupa 234
III. TRAVELLING SALESMAN PROBLEM

Problema 1
a) Considerăm o instant, ă G = (V, E) (graf neponderat) pentru HCP s, i for-
măm un nou graf G′ = (V ′ , E ′ ) (graf complet, ponderat) pentru TSP în
felul următor:

• V′ =V
• cost(u, v) = 1, dacă (u, v) ∈ E
• cost(u, v) = 2, dacă (u, v) ∈
/E

Astfel, putem folosi un algoritm polinomial pentru TSP pe graful G′ pentru

a verifica existent, a unui ciclu hamiltonian în graful G.
Graful G are un ciclu hamiltonian doar dacă algoritmul polinomial pen-
tru problema TSP pe graful G′ returnează rezultatul |V | drept costul mi-
nim necesar comis-voiajorului. Dacă rezultatul algoritmului este strict mai
mare decât |V |, atunci G nu are un ciclu hamiltonian.
Astfel, s-ar putea rezolva HCP în timp polinomial. Din moment ce HCP
este NP-complete, rezultă că problema TSP, inclusiv în varianta cu costuri
1 sau 2, rămâne NP-hard.

b)

c) Algoritmul nu este 3/2-aproximativ deoarece depinde de forma M ST -ului

ales. De exemplu, pentru un graf complet cu 6 noduri s, i toate muchiile cu
costul 1, următorul M ST este posibil:

v1

v2 v3 v4 v5 v6

Pentru acest M ST , ALG = 10, dar OP T = 6. ALG

OP T = 10
6 > 3
2 =⇒
algoritmul nu este 3/2-aproximativ.

1
Tema 1 – Algoritmi Avansat, i
Nicula Ionut, -Cosmin
Grupa 234
IV. VERTEX COVER

a) Considerăm o expresie cu n = 2m + 1, m > 0 de forma:

(x1 ∨ x2 ∨ x3 ) ∧ (x1 ∨ x4 ∨ x5 ) ∧ (x1 ∨ x6 ∨ x7 ) ∧ ... ∧ (x1 ∨ x2m ∨ x2m+1 )

sau

m
^
(x1 ∨ x2j ∨ x2j+1 )
j=1

Pentru acestă formă, OP T = 1 (expresia se poate rezolva într-un singur

pas, prin x1 ← T rue).
Pe de altă parte, există posibilitatea ca algoritmul din enunt, să selecteze
la fiecare pas o variabilă care apare într-un singur predicat (xi , i ≥ 2).
Astfel, pentru fiecare iterat, ie în care se alege o astfel de variabilă, s-ar
elimina din lista de predicate rămase un singur predicat. O serie de alegeri
(predicat, variabilă) cu această proprietate este:

(C1 , x2 ), (C2 , x4 ), (C3 , x6 ), ..., (Cm , x2m )

Eliminând câte un predicat la fiecare iterat, ie, în cel mau rău caz ALG = m.
Deci, algoritmul este m-aproximativ.

b)

c) Formularea problemei sub forma unei progreme de programare liniară:

Fie multimea de variabile X = {x1 , x2 , ..., xn }.
Fie multimea de predicate C = {C1 , C2 , ..., Cm }.
Ci = {xa , xb , xc ∈ X}, 1 ≤ i ≤ m.

Găses, te s, irul S = {s1 , s2 , ..., sn }

Pn
care minimizează i=1 si
având constrângerile s ∈ {0, 1}, ∀s ∈ S
s, i xi ∈ X ⇐⇒ si ∈ S, ∀i ∈ {1, 2, ..., n}
s, i xi , xj , xk ∈ Cl =⇒ si + sj + sk > 0, ∀l ∈ {1, 2, ..., m}