algoritmi e strutture dati--lecture...

Algoritmi e Strutture Dati

Giuseppe Persiano

Dipartimento di Informatica ed Appl. Renato M. Capocelli

Universita di Salerno

Indice

Capitolo 1. Divide et Impera 51. Master theorem 52. Mergesort 53. Il numero mancante 64. Moltiplicazione di matrici 7

Capitolo 2. Calcolo della mediana 91. Un algoritmo lineare non realistico 92. Un algoritmo probabilistico 103. Algoritmo deterministico 11

Capitolo 3. Programmazione dinamica 131. Espressione minima di valore dato 132. Muoversi su una scacchiera 17

Capitolo 4. Algoritmo greedy per zaino frazionario 19

Capitolo 5. Algoritmi di Ricerca 211. Ricerca esaustiva 212. Backtrack 223. Branch and Bound 25

Capitolo 6. NP-completezza 291. La classe P 292. La classe NP 293. La classe NP− COMPLETE 314. Il linguaggio CNFSAT 325. Il linguaggio 3SAT 326. Il linguaggio Clique 337. Il linguaggio 3Col 348. Esercizi 35Note bibliografiche 36

Bibliografia 37

3

4 INDICE

SommarioQuesto documento contiene le note per il corso di Algoritmi e Strutture Dati che l’autore ha tenuto

nell’anno accademico 2005/2006 presso la Facolta di Scienze dell’Universita di Salerno.

CAPITOLO 1

Divide et Impera

In questo capitolo discuteremo alcuni algoritmi progettati mediante la tecnica di progettazione delDivide et Impera. Algoritmi progettati usando questa tecnica consistono di tre fasi:

Divide: Il problema e diviso in sottoproblemi piu piccoli.Impera: Ciascuno dei sottoproblemi e risolto ricorsivamente.Combina: Le soluzioni dei sottoproblemi sono combinate in modo da ottenere la soluzione al

problema originale.La ricorsione si ferma quando si ottengono problemi di taglia costante c che sono risolti in tempocostante. Il tempo di esecuzione T (n) di un algoritmo Divide et Impera per input di taglia n edescritto tipicamente da un’equazione di ricorrenza. Se la fase Impera risolve b problemi ciascuno ditaglia al piu n/a e le fasi Divide e Combina prendono tempo f(n) allora abbiamo

T (n) =

aT (n/b) + f(n), se n > c;Θ(1), altrimenti;

dove c e una costante.

1. Master theorem

Teorema 1.1 (Recurrence Master Theorem). Siano a ≥ 1, b > 1 costanti, sia f(n) una funzionenon negativa e sia T (n) definita come

T (n) = aT (n/b) + f(n)

ove intepretiamo n/b come bn/bc o come dn/be. Allora abbiamo

(1) Se esiste un ε > 0 tale che f(n) = O(nlogb a−ε), allora

T (n) = Θ(nlogb a).

(2) Se f(n) = Θ(nlogb a logk n), allora

T (n) = Θ(nlogb a logk+1 n).

(3) Se esiste un ε > 0 tale che f(n) = Ω(nlogb a+ε) ed esiste una constante c < 1 tale cheaf(n/b) ≤ cf(n), allora

T (n) = Θ(f(n)).

2. Mergesort

L’equazione di ricorrenza che descrive il tempo di esecuzione del Mergesort e

T (n) = 2T (n/2) + n.

Applicando il Master Theorem (caso 2 con k = 0) abbiamo T (n) = Θ(n log n).

5

6 1. DIVIDE ET IMPERA

3. Il numero mancante

L’input consiste di una matrice binaria A di dimensione k × 2k − 1. Ciascuna colonna puo essereinterpretata come la rappresentazione binaria di un intero dell’intervallo I = [0, 2k − 1]. Supponiamoche le colonne rappresentano interi diversi e quindi esiste esattamente un intero dell’intervallo I che none rappresentato da alcuna colonna di A. Vogliamo progettare un algoritmo che trova l’intero mancante.

A =

0 0 1 1 0 0 10 1 0 0 1 0 11 0 0 1 1 0 1

Figura 1. Una possibile matrice input con k = 3. L’intero mancante e 6 (conrappresentazione binaria 110).

Consideriamo come costo di un algoritmo il numero di entrate della matrice A che l’algoritmo legge.L’algoritmo che legge tutti i valori della matrice A ha costo k(2k − 1); di seguito descriveremo unalgoritmo che ha costo 2k+1 − k − 1.

NumeroMancante(A, r, k, L)

01. L1 = L0 = ∅;02. for c ∈ L03. if A[r, c] = 0 then04. L0 = L0 ∪ c;05. else06. L1 = L1 ∪ c;07. if |L1| > |L0| then08. if r == k then09. return (0);10. else11. x←NumeroMancante(A, r + 1, k, L0);12. return (0 + x);13. else14. if r == k then15. return (1);16. else17. x←NumeroMancante(A, r + 1, k, L1);18. return (1 + x);

La chiamata iniziale e NumeroMancante(A, 1, k, I). L’operazione + alle linee 18 e 12 indicala concatenazione di stringhe binarie. L’algoritmo restituisce la rappresentazione binaria dell’interomancante.

A =

0 0 1 1 0 0 1∗ ∗ 0 0 ∗ ∗ 1∗ ∗ ∗ ∗ ∗ ∗ 1

Figura 2. Le 11 entrate della matrice A lette dall’algoritmo NumeroMancante.

4. MOLTIPLICAZIONE DI MATRICI 7

3.1. Analisi. Consideriamo come taglia del problema la cardinalita dell’insieme L. Ispezionandoil codice, vediamo che la fase Divide prende tempo O(|L|) e la fase Combina prende tempo O(1). Per lafase Impera osserviamo che l’algoritmo soddisfa la seguente invariante. Si consideri la sottomatrice Sche consiste delle righe da r a k e delle colonne dell’insieme L. S ha 2k−r+1−1 colonne e tutti gli interitranne esattamente 1 dell’intervallo Ir = [0, 2k−r+1 − 1] appaiono (come rappresentazione binaria)come colonna di S. Osserviamo che l’invariante e certamente soddisfatta dalla prima invocazionedell’algoritmo. Supponiamo che valga per l’r-esima invocazione e proviamo che vale anche per lasuccessiva. Durante la r-esima invocazione l’algoritmo legge tutti i bit della prima riga di S e costruiscel’insieme L0 di tutte (gli indici del)le colonne di S che hanno uno 0 nella prima riga e l’insieme L1

di tutte le colonne che invece hanno un 1 e poi effettua una chiamata ricorsiva sul piu piccolo deidue. Per ipotesi induttiva le colonne di S rappresentano tutti gli interi tranne uno dell’intervallo Ir.Pertanto il numero di 1 e 0 che compaiono nella prima riga di S (corrispondenti ai bit piu significativi)differisce esattamente di 1 ed il bit mancante e il bit piu significativo dell’intero mancante. Quindil’insieme L che viene dato come argomento alla (r+1)-esima invocazione dell’algoritmo ha cardinalitaesattamente 2k−r − 1. Inoltre la sottomatrice corrispondente rappresenta tutti gli interi tranne unodell’intervallo Ir+1 = [0, 2k−r − 1].

Abbiamo quindi la seguente equazione di ricorrenza

(1) T (2k − 1) = 1 · T (2k−1 − 1) + 2k − 1.

Sostituendo n per 2k − 1 abbiamo che

T (n) = 1 · T (bn/2c) + n

e quindi cadiamo nel caso generale con a = 2, b = 1 e f(n) = n per cui abbiamo T (n) = Θ(n) = Θ(2k).Applicando il Master Theorem abbiamo ottenuta il comportamento asintotico dell’algoritmo. Per

questo algoritmo possiamo raffinare l’analisi ed ottenere un conteggio preciso del numero di entratedella matrice A visitate. Espandendo l’Eq. 1 otteniamo,

T (2k − 1) = T (2k−1 − 1) + 2k − 1

= T (2k−2 − 1) + 2k + 2k−1 − 2

= T (2k−3 − 1) + 2k + 2k−1 + 2k−2 − 3= · · · · · ·= T (1) + 2k + · · ·+ 22 − (k − 1)

(usando T (1) = 1)

=k∑

i=0

2i − k − 1

= 2k+1 − k − 2

4. Moltiplicazione di matrici

Consideriamo due matrici A e B quadrate di dimensione n supponiamo di voler calcolare il loroprodotto C. L’algoritmo standard per calcolare il prodotto C usa la definizione stessa di prodotto epuo essere descritto nel modo seguente.

MatriceMult(A,B, C, n)

01. for i = 1 to n

8 1. DIVIDE ET IMPERA

02. for j = 1 to n03. cij = 0;04. for k = 1 to n05. cij = cij + aik · bkj

Il tempo di esecuzione di questo algoritmo e Θ(n3).Possiamo progettare un algoritmo di Divide et Impera basandoci sull’osservazione che una matrice

n×n puo essere vista come una matrice 2×2 ove ciascun elemento e a sua volta una matrice n/2×n/2.

[r st u

]=

[a bc d

]·[

e fg h

] r = ae + bgs = af + bht = ce + dgu = cf + dh

In questo modo riduciamo una moltiplicazione di matrici di taglia n × n in 8 moltiplicazionidi matrici di taglia n/2 × n/2. Inoltre abbiamo bisogno di Θ(n2) per sommare i prodotti parziali.Pertanto, denotando con T (n) il numero di passi dell’algortimo per moltiplicare due matrici di taglian× n, abbiamo

T (n) = 8 · T (n/2) + Θ(n2)ed applicando il Master Theorem otteniamo T (n) = Θ(n3).

4.1. Algoritmo di Strassen. Esiste invece un modo piu efficiente di moltiplicare le 8 sottoma-trici in modo da ottenere il prodotto desiderato scoperto da V. Strassen nel 1969 [6].

Ponendo

P1 = a · (f − h)P2 = (a + b) · hP3 = (c + d) · eP4 = d · (g − e)P5 = (a + d) · (e + h)P6 = (b− d) · (g + h)P7 = (a− c) · (e + f)

abbiamo che

r = P5 + P4 − P2 + P6

s = P1 + P2

t = P3 + P4

u = P5 + P1 − P3 − P7

Petanto abbiamo ridotto il problema di calcolare un prodotto di due matrici di taglia n×n al problemadi calcolare 7 prodotti di matrici di taglia n/2 × n/2. Inoltre abbiamo bisogno di tempo Θ(n2) percombinare i prodotti parziali al fine di ottenere le matrici r, s, t e u.

Abbiamo quindiT (n) = 7 · T (n/2) + Θ(n2)

ed applicando il Master Theorem otteniamo

T (n) = Θ(nlog2 7) = O(n2.81).

Versione: 1.7–8 ottobre 2005.

CAPITOLO 2

Calcolo della mediana

Sia data una sequenza S = (s1, · · · , sn) di n elementi. Per semplicita assumiamo che gli elementidi S siano distinti; cioe i 6= j implica che si 6= sj .

Per 1 ≤ i ≤ n, l’i-esimo elemento piu piccolo e l’elemento x tale che1. x ∈ S;2. l’insieme y|y ∈ Se y ≤ x ha cardinalita i.

Quindi per i = 1, l’i-esimo elemento piu piccolo di S e il minimo di S mentre, per i = n, l’i-esimoelemento piu piccolo di S e il massimo di S.

Se n e dispari, la mediana di S e l’i-esimo elemento piu piccolo con i = dn/2e. Se invece n e pari,S ammette due mediane: l’i-esimo e l’(i + 1)-esimo elemento piu piccolo con i = n/2.

1. Un algoritmo lineare non realistico

Supponiamo ora di avere una “scatola magica” A che, ricevendo in input una sequenza S, restituiscein output la mediana di S in tempo lineare. In particolare se S ha un numero dispari di elementi, Arestituisce la mediana m. Se invece S ha un numero pari di elementi, A restituisce le due medianem1 < m2 di S. A questo punto non sappiamo se un tale algoritmo esiste ma questo esercizio ci aiuteraa capire meglio il problema che stiamo studiando.

Il seguente algoritmo utilizza A per calcolare l’i-esimo elemento piu piccolo di S per ogni dato iin tempo lineare nella lunghezza di S.SelezioneConA(S, n, i)01. if n = 1 then02. return s1;03. if n pari then04. (m1,m2) = A(S);05. costruisci l’insieme L degli elementi di S minori di m1;06. costruisci l’insieme R degli elementi di S maggiori di m2;07. if i < n/2 then08. return SelezioneConA(L, n/2− 1, i)09. if i = n/2 then10. return m1;11. if i = n/2 + 1 then12. return m2;13. if i > n/2 + 1 then14. return SelezioneConA(R,n/2− 1, i− n/2− 1);15. if n dispari then16. m = A(S);17. costruisci l’insieme L degli elementi di S minori di m;18. costruisci l’insieme R degli elementi di S maggiori di m;19. if i < dn/2e then20. return SelezioneConA(L, dn/2e − 1, i);

9

10 2. CALCOLO DELLA MEDIANA

21. if i = dn/2e then22. return m;23. if i > dn/2e then24. return SelezioneConA(R, dn/2e − 1, i− dn/2e+ 1);25. end ;

Osserviamo che l’algoritmo SelezioneConA quando riceve in input una sequenza di lunghezza n,richiama se stesso su una sequenza di lunghezza al piu n/2. Pertanto se denotiamo con T (n) il tempoimpiegato da SelezioneConA quando riceve in input una sequenza di n elementi, possiamo scrivere

T (n) = T (n/2) + Θ(n)

da cui concludiamo, usando il Master Theorem, che T (n) = Θ(n).

2. Un algoritmo probabilistico

Supponiamo invece di avere a disposizione un algoritmo B che, ricevendo in input una sequenza S,ci restituisce un elemento x che e “vicino” alla mediana. Piu precisamente, x e almeno grande quantoil k1-esimo elemento piu piccolo di S e non piu grande del k2-esimo elemento piu piccolo di S conk1 = n/4 e k2 = 3/4n (per semplicita assumiamo che n sia multiplo di 4 e quindi k1 e k2 sono interi).SelezioneConB(S, n, i)01. if n = 1 then02. return s1;03. x = B(S);04. costruisci l’insieme L degli elementi di S minori di x;05. costruisci l’insieme R degli elementi di S maggiori di x;06. if i < |L|+ 1 then07. return SelezioneConB(L, |L|, i)08. if i = |L|+ 1 then09. return x;10. if i > |L|+ 2 then11. return SelezioneConB(R,n− |L| − 1, i− |L| − 1);12. end ;

Per analizzare l’algoritmo SelezioneConB possiamo seguire un ragionamente simile a quello fattoper SelezioneConA. Osserviamo infatti che l’algoritmo SelezioneConB quando riceve in input unasequenza di lunghezza n, richiama se stesso su una sequenza di lunghezza al piu 3/4n. Pertanto sedenotiamo con T (n) il tempo impiegato da SelezioneConB quando riceve in input una sequenza din elementi, possiamo scrivere

T (n) = T (3n/4) + Θ(n)da cui concludiamo che T (n) = Θ(n).

A differenza dell’algortimo A, e possibile progettare un’implementazione probabilistica dell’algo-ritmo B: basta selezionare un elemento x a caso della sequenza S. Con probabilita 1/2 l’elementoselezionato x e abbastanza vicino alla mediana.SelezioneProb(S, n, i)01. if n = 1 then02. return s1;03. repeat04. scegli x a caso da S;

3. ALGORITMO DETERMINISTICO 11

05. costruisci l’insieme L degli elementi di S minori di x;06. costruisci l’insieme R degli elementi di S maggiori di x;07. l = max(|L|, |R|);08. until l ≤ 3/4n;09. if i < |L|+ 1 then10. return SelezioneProb(L, |L|, i)11. if i = |L|+ 1 then12. return x;13. if i > |L|+ 2 then14. return SelezioneProb(R,n− |L| − 1, i− |L| − 1);15. end ;

La probabilita che l sia minore o uguale a 3/4n e uguale a 1/2. Quindi il loop repeat delle linee3-8 e eseguito in media 2 volte e ciascuna iterazione prende tempo Θ(n). Inoltre, la sequenza su cuie ricorsivamente invocata SelezioneProb ha lunghezza al piu 3/4n. Quindi denotiamo con T (n) iltempo medio di esecuzione di SelezioneProb per una sequenza di lunghezza n e scriviamo

T (n) = T (3n/4) + Θ(n)

da cui concludiamo che T (n) = Θ(n).

3. Algoritmo deterministico

Un algoritmo deterministico per calcolare l’i-esimo elemento piu piccolo e stato presentato da M.Blum, R. Floyd, V. Pratt, R. Rivest e R. Tarjan (vedi [1]). Vedi anche il libro di testo.

Versione: 1.9 del 27 ottobre 2005.

CAPITOLO 3

Programmazione dinamica

In questo capitolo presentiamo la soluzione di alcuni esercizi che riguardano algoritmi progettatiusando la tecnica della programmazione dinamica.

1. Espressione minima di valore dato

Riceviamo in input un insieme X di n interi positivi ed un intero target T . Desideriamo decidere seesiste un’espressione X-legale con valore T . Un’espressione con valore T e X-legale (o semplicementelegale, quando l’insieme X e chiaro dal contesto) se contiene solo gli elementi di X (anche ripetuti),addizioni, moltiplicazioni e parentesi.

Ad esempio se X = 2, 4, 5, 11, 21 allora E1 = ((4 + 5) ∗ (2 + 11)) + 4 e un’espressione legale convalore 121. L’espressione E2 = ((4 + 7) ∗ (2 + 11)) ∗ 4 non e invece un’espressione legale in quantocontiene un intero, 7, che non appartiene a X.

Se T ∈ X allora ovviamente esiste un’espressione legale con valore T . Ogni espressione E che con-tiene almeno un’addizione o una moltiplicazione puo essere scritta nel modo seguente E = E1 op E2,dove op e + oppure ∗. Chiameremo l’operazione op, l’ultima operazione di E, in quanto nel valutarel’espressione E, op sara eseguita per ultima.

Osserviamo che se un’espressione E ha valore T allora siamo in uno dei due seguenti casi.(1) L’ultima operazione di E e un’addizione.

In questo caso E puo essere scritta come E = E1 + E2. Se indichiamo con x il valoredell’espressione E1 abbiamo che E2 ha valore T − x. Inoltre, senza perdita di generalita(WLOG), possiamo assumere che x sia intero e appartenga all’intervallo [1, T/2].

(2) L’ultima operazione di E e una moltiplicazione.In questo caso E puo essere scritta come E = E1 ∗ E2. Se indichiamo con x il valore

dell’espressione E1 abbiamo che E2 ha valore T/x. Inoltre, WLOG, possiamo assumere chex sia intero, che divida T e appartenga all’intervallo [2,

√T ].

Per le due osservazioni di sopra, possiamo concludere che esiste un’espressione legale per T se esolo se almeno una delle due seguente proposizione e vera.

(1) esiste x ∈ [1, T/2] tale che esistono espressioni legali per x e T − x;(2) esiste x ∈ [2,

√T ] tale che esistono espressioni legali per x e T/x.

Quindi abbiamo ridotto il problema di decidere l’esistenza di un’espressione legale per T al problemadi decidere l’esistenza di espressioni legali per valori minori di T . Possiamo quindi decidere l’esistenzadi un’espressione legale partendo da 1 fino ad arrivare a T usando le osservazioni di cui sopra. Per 1osserviamo che esiste un’espressione X-legale di valore 1 se e solo se 1 ∈ X. Infatti se 1 6∈ X, ogniespressione X-legale conterra interi maggiori di 1 e le operazioni di addizione e sottrazione e quindiavra valore maggiore di 1.EspressioneLegale(X, T )01. if 1 ∈ X then02. E(1) = 1;03. else

13

14 3. PROGRAMMAZIONE DINAMICA

04. E(1) = 0;05. for t = 2 to T06. E(t) = 0;07. if t ∈ X then08. E(t) = 1;09. else10. for x = 1 to t/211. E(t) = E(t) ∨ (E(x) ∧ E(t− x));12. endfor13. for x = 2 to

√t

14. if x divide t then15. E(t) = E(t) ∨ (E(x) ∧ E(t/x));16. endfor17. endfor18. return E(T );

L’algoritmo descritto dallo pseudocodice di sopra (come tutti gli altri relativo a variazione sulproblema) prende tempo polinomiale in T e pertanto non e polinomiale. Un algoritmo per esserepolinomiale deve compiere un numero di passi polinomiale nella lunghezza in bit dell’input. Se T halunghezza n e X contiene m elementi allora l’istanza (X, T ) puo essere scritta usando O(nm) bit.L’algoritmo invece prende tempo polinomiale in T = Θ(2n) e quindi non e polinomiale.

1.1. Espressione di costo minimo. Consideriamo il problema della sezione precedente masupponiamo di associare un costo Cost(E) ad ogni espressione E e di voler calcolare su input (X, T )il costo minimo di un’espressione X-legale di valore T . Definiamo il costo di un’espressione come ilnumero di operazioni dell’espressione. Ad esempio se X = 2, 4, 5, 11, 21 allora E1 = ((4 + 5) ∗ (2 +11))+4 e un’espressione legale con valore 121 di costo 4. L’espressione E2 = ((4+5)∗ (2+11))∗4+21e invece un’espressione legale di valore 489 e di costo 5.

Consideriamo l’espressione minima E di valore T . Come in precedenza possiamo avere due casi.

(1) L’ultima operazione di E e un’addizione.In questo caso E puo essere scritta come E = E1 + E2. Se indichiamo con x il valore

dell’espressione E1 abbiamo che E2 ha valore T − x. Inoltre, senza perdita di generalita(WLOG), possiamo assumere che x sia intero e appartenga all’intervallo [1, T/2]. Notiamoora che E1 e un’espressione di valore x di costo minimo. Se cosı non fosse, esisterebbeun’espressione E1 di valore x e di costo minore di E1. Quindi l’espressione E = E1 + E2

ha valore T e costa meno di E, contraddicendo il fatto che E ha costo minimo. Un simileargomento vale per E2.

(2) L’ultima operazione di E e una moltiplicazione.In questo caso E puo essere scritta come E = E1 ∗ E2. Se indichiamo con x il valore

dell’espressione E1 abbiamo che E2 ha valore T/x e, usando un argomento simile a quellodel caso precedente, abbiamo che E1 e un’espressione di costo minimo per x e che E2 eun’espressione di costo minimo per T/x.

1. ESPRESSIONE MINIMA DI VALORE DATO 15

Quindi, denotando con C(T,+) (rispettivamente, C(T, ∗)) il costo minimo di un’espressione X-legale di valore T con ultima operazione + (rispettivamente ∗) e con C(T ) il costo minimo di un’e-spressione X-legale di valore T abbiamo che

C(T ) = minC(T,+), C(T, ∗)(2)C(T,+) = min

1≤x≤T/2C(x) + C(T − x) + 1(3)

C(T, ∗) = min2≤x≤

√T

x|T

C(x) + C(T/x) + 1(4)

Come nel caso precedente, abbiamo ridotto il problema di calcolare il costo di un’espressione di costominimo per T al problema del calcolo dei costi di un’espressione di costo minimo per valori minori diT .

Abbiamo pertanto il seguente algoritmo

MinEspressioneLegale(X, T )01. for t = 1 to T02. if t ∈ X then03. C(t) = 0;04. else05. C(t, +) = min1≤x≤t/2C(x) + C(t− x) + 1;06. C(t, ∗) = min

xdivide t

2≤x≤√

t

C(x) + C(t/x) + 1;

07. minC(T,+), C(T, ∗);08. endfor;09. return C(T );

Esercizio 3.1. Si definisca il costo di un’espressione E che contiene k1 addizioni e k2 moltiplica-zioni come Cost(E) = 2 · k1 + 3 · k2. Si modifichi l’algoritmo di cui sopra in modo che restituisca ilcosto minimo (rispetto alla nuova definizione) di un’espressione di valore T .

1.2. Una moltiplicazione. In questa sezione, studiamo una variazione del problema della sezio-ne precedente. Modifichiamo la definizione di espressione X-legale nel modo seguente. Un’espressionecon valore T e X-legale (o semplicemente legale quando l’insieme X e chiaro dal contesto) se con-tiene solo gli elementi di X (anche ripetuti), addizioni ed al piu una moltiplicazione. Ad esempiose X = 2, 4, 5, 11, 21 allora E1 = ((4 + 5) ∗ (2 + 11)) + 4 e un’espressione legale con valore 121.L’espressione E2 = ((4 + 5) ∗ (2 + 11)) ∗ 4 non e invece un’espressione legale in quanto comprende duemoltiplicazioni. Come prima, il costo di un’espressione E e semplicemente il numero di operazioni diE. Ad esempio, E1 costa 4.

(1) Indichiamo con S(t) l’insieme di tutte l’espressioni legali con valore t e con C(t) il minimodei costi delle espressioni in S(t).

(2) L’insieme di tutte le espressioni di valore t puo essere partizionato in due insiemi: l’insiemeS(t, 0) delle espressioni che non contengono moltiplicazioni e l’insieme S(t, 1) delle espressioniche contengono esattamente una moltiplicazione. Denotando con C(t, 0) e C(t, 1) il costo dellaminima espressione di ciascun insieme, abbiamo che C(t) = minC(t, 0), C(t, 1).

(3) In ogni espressione e possibile individuare l’operazione che e eseguita per ultima e questa puoessere un’addizione o una moltiplicazione. Pertanto, poniamo le seguenti definizioni:• S(t, 1, ∗) e l’insieme di tutte le espressioni che hanno valore t, contengono una moltipli-

cazione e l’ultima operazione e una moltiplicazione e denotiamo con C(t, 1, ∗) il costominimo di un’espressione di questo insieme.


• S(t, 1,+) e l’insieme di tutte le espressioni che hanno valore t, contengono una moltipli-cazione e l’ultima operazione e una addizione e denotiamo con C(t, 1,+) il costo minimodi un’espressione di questo insieme.• S(t, 0,+) e l’insieme di tutte le espressioni che hanno valore t, non contengono moltipli-

cazioni e l’ultima operazione e una addizione e denotiamo con C(t, 0,+) il costo minimodi un’espressione di questo insieme.

Notiamo ora che S(t, 1) = S(t, 1, ∗) ∪ S(t, 1,+) e quindi C(t, 1) = minC(t, 1, ∗), C(t, 1,+).Inoltre, abbiamo S(t, 0,+) = S(t, 0) e quindi C(t, 0,+) = C(t, 0);

(4) Un’espressione E di S(t, 0,+) ha la forma E = E1 +E2 ove E1 ha valore a, con 1 ≤ a ≤ t− 1e non contiene alcuna moltiplicazione (quindi E1 ∈ S(a, 0)) e E2 ha valore (t − a) e noncontiene alcuna moltiplicazione (quindi E2 ∈ S(t− a, 0)).

Inoltre osserviamo che se E e l’espressione di costo minimo tra quelle di S(t, 0,+) alloraanche E1 ed E2 hanno costo minimo in S(a, 0) e S(t− a, 0), rispettivamente.

Possiamo quindi affermare che

C(t, 0,+) = min1≤a≤t−1

C(a, 0) + C(t− a, 0) + 1.

(5) Un’espressione E di S(t, 1,+) ha la forma E = E1 +E2 ove E1 ha valore a, con 1 ≤ a ≤ t− 1e contiene una moltiplicazione (quindi E1 ∈ S(a, 1)) e E2 ha valore (t − a) e non contienealcuna moltiplicazione (quindi E2 ∈ S(t− a, 0)).

Come al passo precedente osserviamo che se E ha costo minimo anche E1 ed E2 avrannocosto minimo (in S(a, 1) e S(t− a, 0), rispettivamente) e quindi deduciamo che

C(t, 1,+) = min1≤a≤t−1

C(a, 1) + C(t− a, 0) + 1.

(6) Un’espressione E di S(t, 1, ∗) ha la forma E = E1 ∗E2 ove E1 ha valore a, con 2 ≤ a ≤ t− 1e a divisore di t, e non contiene alcuna moltiplicazione (quindi E1 ∈ S(a, 0)) e E2 ha valore(t/a) e non contiene alcuna moltiplicazione (quindi E2 ∈ S(t/a, 0)).

Seguendo un ragionamento simile a quello del passo precedente abbiamo

C(t, 1, ∗) = mina|t

2≤a≤t−1

C(a, 0) + C(t/a, 0) + 1.

Abbiamo pertanto il seguente algoritmo

MinEspressioneLegaleUnaMolt(X, T )01. for t = 1 to T02. if t ∈ X then03. C(t, 0) = C(t, 1) = 0;04. else05. C(t, 1,+) = min1≤a≤t−1C(a, 1) + C(t− a, 0) + 1;06. C(t, 1, ∗) = min a|t

2≤a≤t−1C(a, 0) + C(t/a, 0) + 1;

07. C(t, 1) = minC(t, 1,+), C(t, 1, ∗);08. C(t, 0) = min1≤a≤t−1C(a, 0) + C(t− a, 0) + 1;09. end;10. return minC(T, 0), C(T, 1);

Nel calcolo del minimo ai passi 5, 6, 7, 8 assumiamo che il minimo di un insieme vuoto sia +∞.Notiamo che alla t-esima iterazione del ciclo for, l’algoritmo calcola i valori di C(·, ·) e C(·, ·, ·) usandoi valori della funziona per valori del primo argomento minori di t che sono stati gia calcolati ai passiprecedenti. L’algoritmo impiega tempo O(T 2) ed e pertanto pseudopolinomiale.

2. MUOVERSI SU UNA SCACCHIERA 17

Esercizio 3.2. Considerare il caso in cui desideraimo l’espressione di costo minimo tra quelle chehanno valore T e al piu k moltiplicazioni.

2. Muoversi su una scacchiera

E data una scacchiera n×n e una pedina. La pedina puo muoversi sulla scacchiera in accordo allaseguenti regole. Se la pedina si trova alla posizione (x, y) con x < n, allora puo muoversi

(1) alla posizione (x + 1, y);(2) alla posizione (x+1, y−1) tranne nel caso in cui y = 1 (la pedina si trova sulla prima colonna

della scacchiera);(3) alla posizione (x+1, y+1) tranne nel caso in cui y = n (la pedina si trova sull’ultima colonna

della scacchiera).Ogni volta che la pedina compie una mossa legale e si muove dalla posizione (x1, y1) alla posizione

(x2, y2) riceve un pagamento pari a p((x1, y1), (x2, y2)).Progettiamo un algoritmo che, avendo accesso alla matrice dei pagamenti p(·, ·), individui la se-

quenza di mosse che porta la pedina dalla prima all’ultima riga della scacchiera e che massimizza lasomma dei pagamenti ricevuti. L’algoritmo puo scegliere qualsiasi posizione di partenza sulla primariga e qualsiasi posizione di arrivo sull’ultima riga.

Denotiamo con M(x, y) il massimo pagamento ottenibile da una sequenza di mosse che parte dallaposizione (x, y) e che arriva ad una posizione sull’ultima riga della scacchiera. Ovviamente abbiamoche M(n, y) = 0, per ogni 1 ≤ y ≤ n. Se invece 1 ≤ x < n abbiamo

M(x, y) =

max M(x + 1, y) + p((x, y), (x + 1, y)),M(x + 1, y + 1) + p((x, y), (x + 1, y + 1)) , sey=1;

max M(x + 1, y) + p((x, y), (x + 1, y)),M(x + 1, y − 1) + p((x, y), (x + 1, y − 1)) , sey=n;

max M(x + 1, y) + p((x, y), (x + 1, y)),M(x + 1, y − 1) + p((x, y), (x + 1, y − 1)),M(x + 1, y + 1) + p((x, y), (x + 1, y + 1)) , altrimenti.

Progettiamo quindi un algoritmo che calcola la matrice M(x, y) per valori decrescenti di x. Unavolta calcolati M(1, y) per 1 ≤ y ≤ n il valore richiesto e il massimo di M(1, y) per 1 ≤ y ≤ n.

L’algoritmo discusso e descritto dal seguente pseudocodiceAlgoritmoPedina(n, p(·, ·))

01. for y = 1 to n02. M(n, y) = 0;03. end;04. for x = n− 1 downto 105. for y = 1 to n06. M(x, y) = M(x, y + 1) + p((x, y), (x + 1, y));07. S(x, y) = 0;08. if (y 6= 1) and M(x + 1, y − 1) + p((x, y), (x + 1, y − 1)) > M(x, y) then09. M(x, y) = M(x + 1, y − 1) + p((x, y), (x + 1, y − 1));10. S(x, y) = −1;11. if (y 6= n) and M(x + 1, y + 1) + p((x, y), (x + 1, y + 1)) > M(x, y) then12. M(x, y) = M(x + 1, y + 1) + p((x, y), (x + 1, y + 1));13. S(x, y) = +1;


14. end;15. end;16. M = M(1, 1);17. S = 1;18. for y = 2 to n19. if (M < M(1, y)) then20. M = M(1, y);21. S = y;22. end;23. PrintLa sequenza di massimo profitto vale M ;24. Printe consiste delle seguenti mosse;25. for x = 1 to n− 126. Print((x, S), (x + 1, S + S(x, y));27. S = S + S(x, y);

Versione: 1.7 del 19 dicembre 2005.

CAPITOLO 4

Algoritmo greedy per zaino frazionario

Il problema dello zaino frazionario e definito nel modo seguente.Input: n oggetti 1, 2, · · · , n ciascuno caratterizato da un peso wi > 0 e da un prezzo pi > 0; unpeso massimo B > 0.Soluzioni Ammissibili: (c1, · · · , cn) ∈ [0, 1]n tale che

n∑i=1

ci · wi ≤ B.

Valore di una soluzione: alla soluzione ammissibile C = (c1, · · · , cn) e associato il valore v(C) =∑ni=1 ci · pi e ovviamente vogliamo la soluzione ammissibile di valore massimo.

Proviamo che il seguente algoritmo produce una soluzione ottima. Assumiamo che gli oggettiin input sono ordinati in ordine decrescente per rapporto prezzo/peso pi/wi. Supponiamo inoltre,senza perdita di generalita, che non esistono due oggetti con lo stesso rapporto prezzo/peso. Infattise abbiamo p1/w1 = p2/w2 possiamo considerare un oggetto fittizio di peso w1 + w2 e prezzo p1 + p2.Una soluzione che contiene una frazione 0 ≤ c ≤ 1 dell’oggetto fittizio puo essere considerata comeuna soluzione che contiene una frazione c/2 di ciascuno dei due oggetti originari. Possiamo quindi direche i < j implica che pi/wi > pj/wj .ZainoFrazionario(p, w, B)1. n← Length(p);2. r ← B;3. for i = 1 to n4. if wi ≤ r then5. ci = 1;6. r = r − wi;7. else8. ci = r/wi;9. r = 0;

Proviamo ora che la soluzione C costruita dall’algoritmo ZainoFrazionario e ottima. Iniziamoosservando che esiste 1 ≤ l ≤ n tale che

i < l ⇒ ci = 1;i = l ⇒ 0 ≤ ci < 1;i > l ⇒ ci = 0.

Disitinguiamo due casi. Se ci = 1 per ogni i allora la soluzione include tutti gli oggetti ed e certamenteottima.

Supponiamo invece che esiste l tale che cl < 1. Mostriamo che per ogni soluzione D = (d1, · · · , dn)differente da C di valore v esiste una soluzione D′ di valore v′ > v. Se D differisce da C sia i ≤ l il

19

20 4. ALGORITMO GREEDY PER ZAINO FRAZIONARIO

primo oggetto tale che di < ci e sia j > i un oggetto tale che dj > 0. Scegliamo ε tale che 0 ≤ ε ≤ dj

e di + εwj

wi≤ 1. Modifichiamo la soluzione D ponendo di ← di + εwj

wie dj ← dj − ε. Notiamo che

εwj

wi· wi − εwj = 0

e quindi la nuova soluzione e ammissibile. Abbiamo inoltre

v′ = v + piεwj

wi− εpj

= v +ε

wi(wj · pi − wi · pj) .

Poiche pi/wi > pj/wj abbiamo chewj · pi − wi · pj > 0

e quindi v′ > v.

Versione: 1.2 del 28 dicembre 2005.

CAPITOLO 5

Algoritmi di Ricerca

1. Ricerca esaustiva

Consideriamo problemi computazionali le cui soluzioni ammissibili sono descritte da vettori (x1, · · · , xn)dove ciascun xi appartiene ad un insieme Si. A secondo dei casi, vorremo risolvere un problemadi ottimizzazione: trovare un vettore (x1, · · · , xn) che minimizza (o massimizza) un certo criterioP (x1, · · · , xn); oppure un problema di enumerazione: enumerare tutti i vettori (x1, · · · , xn) che sod-disfano il criterio P (x1, · · · , xn). La tecnica della ricerca esaustiva semplicemente considera tutti ipossibili Πn

i=1|Si| vettori.La discussione degli algoritmi di ricerca e facilitata se consideriamo lo spazio delle soluzioni orga-

nizzato ad albero. La radice (posta al livello 1) rappresenta la soluzione parziale in cui nessuna dellen componenti e stata ancora specificata. Un nodo a livello i ha |Si| figli: uno per ciascun possibilevalore di xi e per comodita consideriamo questo valore come etichetta dell’arco. In tal modo la solu-zione parziale rappresentata dal nodo v e ottenuta leggendo le etichette degli archi che costituisconoil cammino dalla radice al nodo v. Un nodo foglia e una soluzione.

Esempio 1 [Subset Sum]. Sono dati in input n interi positivi w1, · · · , wn ed un intero target M .Desideriamo trovare un sottoinsiemi degli interi wi la cui somma e M .

Se abbiamo n = 4 interi positivi (11, 13, 24, 7) ed M = 31, il problema Subset Sum ammette 2soluzione (11, 13, 7) e (24, 7).

Possiamo descrivere le soluzioni del problema Subset Sum mediante un vettore (x1, · · · , xk) ove(1) ogni intero xi e compreso tra 1 ed n;(2) gli interi sono in ordine crescente: xi < xi+1 per i = 1, · · · k − 1;(3) la somma degli interi il cui indice appare in (x1, · · · , xk) e M :

k∑j=1

wxj = M.

Alternativamente, una soluzione puo essere descritta da un vettore binario: se l’i-esima compo-nente e uguale a 0, l’i-esimo elemento non appartiene al sottoinsieme soluzione; se invece l’i-esimacomponente e uguale a 1, l’i-esimo elemento appartiene al sottoinsieme soluzione (vedi Figura 1). Ingenerale, differenti rappresentazioni dello spazio delle soluzioni sono possibili per lo stesso problema.

Una volta definito l’albero che rappresenta lo spazio delle soluzioni, lo stesso puo essere visitatopartendo dalla radice e generando ad ogni passo un nodo dell’albero. Un nodo che e stato generato mai cui figli non sono stati tutti generati e detto vivo. Il nodo vivo di cui si sta attualmente generandoun figlio e detto l’E-nodo. Un nodo v invece e detto morto se tutti i suoi figli sono stati generati oabbiamo deciso che non e utile espandere v ulteriormente.

Differenti algoritmi di ricerca si ottengono specificando:Criterio di espansione. : Come scegliere il prossimo E-nodo tra tutti i nodi vivi;Criterio di taglio.: Come decidere se e inutile espandere un nodo vivo.

La ricerca esaustiva ad esempio non taglia mai un nodo e puo decidere di espandere i nodi in unordine qualsiasi. Ad esempio, un’espansione in profondita e ottenuta seguendo la seguenti regole:

21

22 5. ALGORITMI DI RICERCA

CCCCC

DDDDD

CCCCC

DDDDD

CCCCC

DDDDD

DDDDD

DDDDDD

A

AAAAA

A

AAAAA

@@

@@

@

A

AAAAA

A

AAAAA

@@

@@

@

Q

QQ

QQ

QQ

QQ

Q

x1=1

x2=1 x2=1

x3=1 x3=1 x3=1 x3=1

x4=1 x4=1 x4=1 x4=1 x4=1 x4=1 x4=1 x4=1

x2=0

x3=0

x4=0 x4=0 x4=0 x4=0

x3=0

x1=0

x2=0

x3=0

x4=0 x4=0 x4=0 x4=0

x3=0

Figura 1. L’albero degli stati per il problema SubsetSum con 4 interi. La topologiadell’albero non dipende dai valori input.

(1) ogni volta che un nodo x figlio dell’E-nodo corrente y e generato, x diviene immediatamenteil nuovo E-nodo;

(2) se il corrente E-nodo invece non ha figli che non siano stati ancora generati, allora il padre diy diviene il prossimo E-nodo;

(3) se y non ha padre (cioe y e la radice) e tutti i suoi figli sono stati generati, allora la ricercatermina.

La ricerca esaustiva puo essere espressa usando il seguente pseudocodice. PEsaustivaTutte()stampa tutte le soluzioni al problema. PEsaustivaMinima invece restituisce nella variabile lasoluzione S di costo minimo (P contiene il costo di S e deve essere inzializzato a +∞).

PEsaustivaTutte(x1, · · · , xk−1)foreach xk ∈ Sk

if (x1, · · · , xk) e’ una soluzioneprint (x1, · · · , xk);

elsePEsaustivaTutte (x1, · · · , xk)

end

PEsaustivaMinima(x1, · · · , xk−1)foreach xk ∈ Sk

if (x1, · · · , xk) e’ una soluzioneif P (x1, · · · , xk) < P ;

P = P (x1, · · · , xk);S = (x1, · · · , xk);

elsePEsaustivaMinima(x1, · · · , xk)

end

2. Backtrack

La tecnica del backtrack ci permette, per alcune istanze del problema, di non esaminare tutte lesoluzioni utilizzando una funzione di bounding per decidere il taglio dei nodi.

2. BACKTRACK 23

2.1. Backtrack per enumerazione. Consideriamo prima il problema di enumerazione. Il back-track genera i nodi eseguendo una visita in profondita ed utilizza una funzione di bounding B con laseguente proprieta:

Bounding per enumerazione.: se B(x1, · · · , xk) restituisce Falso allora non esiste nessuncammino con prefisso (x1, · · · , xk) che porta ad un nodo soluzione.

Pertanto, se durante l’esplorazione dello spazio delle soluzioni giungiamo ad un nodo v corrispondentead una soluzione parziale (x1, · · · , xk) per cui B vale Falso, e inutile esplorare il sottoalbero radicatoin v. Di seguito riportiamo una descrizione in pseudocodice del backtrack.

BacktrackTutte(x1, · · · , xk−1)foreach xk ∈ Sk

if (x1, · · · , xk) e’ una soluzioneprint (x1, · · · , xk);

elseif B(x1, · · · , xk)

BacktrackTutte(x1, · · · , xk)end

Torniamo al problema SubsetSum e consideriamo la rappresentazione delle soluzioni mediantevettori binari (come in Figura 1). Supponiamo senza perdita di generalita che gli interi wi siano ordinatiin ordine crescente. Per definire la funzione B, facciamo le due seguenti osservazioni. Supponiamo diavere una soluzione parziale descritta dal vettore (x1, · · ·xk).

(1) Sek∑

i=1

wi · xi +n∑

i=k+1

wi < M

allora anche sommando tutti i rimanenti interi wk+1, · · · , wn otteniamo un valore minore diM . Pertanto il vettore (x1, · · ·xk) non puo essere esteso ad una soluzione. In altre parole,giunti al nodo v specificato dal cammino (x1, · · ·xk) e inutile esplorare l’albero radicato in vin quanto non vi troveremo alcuna soluzione.

(2) Sek∑

i=1

wi · xi + wk+1 > M

aggiungendo un qualsiasi intero tra quelli ancora da considerare wk+1, · · · , wn otterremocertamente un valore maggiore di M (nota che wk+1 e il minore degli elementi ancora daconsiderare). Come prima, l’albero radicato nel nodo v specificato dal cammino (x1, · · ·xk)non contiene alcuna soluzione.

Con queste osservazioni in mente, scriviamo il seguente algoritmo Backtrack per il problema Subse-tSum. Lo stato corrente e memorizzato nell’array globale (x1, · · · , xn). Gli argomenti s, k e r hannoil seguente significato: s contiene il valore della somma corrente; k e l’indice del prossimo elemento daconsiderare; r, invece, contiene la somma degli elementi ancora da considerare. La chiamata iniziale eSubsetSum(0, 1,

∑ni=1 wi). Assumiamo che w1 ≤M e che

∑ni=1 wi ≥M .

SubsetSum(s, k, r)01. r = r − wk;02. xk = 0;03. if s + r ≥M and s + wk+1 ≤M04. SubsetSum(s, k + 1, r);05. xk = 1;


06. if s + wk = M07. print (x1, · · · , xk);08. return;09. else10. s = s + wk;11. if s + wk+1 ≤M12. SubsetSum(s, k + 1, r);end

Notiamo che alla linea 11 non e necessario controllare chek∑

i=1

wixi +n∑

i=k+1

wi ≥M.

Infatti, vale certamente chek−1∑i=1

wixi +n∑

i=k

wi ≥M

altrimenti non avremo effettuato la chiamata corrente e, poiche xk = 1, abbiamok−1∑i=1

wixi +n∑

i=k

wi =k∑

i=1

wixi +n∑

i=k+1

wi.

2.2. Backtrack per ottimizzazione. Se intendiamo utilizzare la tecnica del backtrack per ri-solvere un problema di massimizzazione la funzione di bounding deve soddisfare la seguente condizione:

Bounding per massimizzazione.: B(x1, · · · , xk) restituisce un limite superiore (upper bound)al costo della migliore soluzione ottenuta espandendo la soluzione parziale (x1, · · · , xk).

Supponiamo che la migliore soluzione trovata finora abbia costo u. Allora se B(x1, · · · , xk) ≤ u,e inutile esplorare l’albero radicato nel nodo (x1, · · · , xk). Possiamo pertanto scrivere il seguentepseudocodice.

BacktrackMassima(x1, · · · , xk−1)foreach xk ∈ Sk

if (x1, · · · , xk) e’ una soluzioneif P (x1, · · · , xk) > u

u = P (x1, · · · , xk);S = (x1, · · · , xk);

elseif B(x1, · · · , xk) > u

BacktrackMassima(x1, · · · , xk)endLa variabile u e inizializzata uguale a −∞.

2.3. Algoritmo backtrack per il problema dello zaino. Consideriamo il problema di mas-simizzazione dello zaino intero. Riceviamo in input n pesi positivi w1, · · · , wn, n profitti positivip1, · · · , pn ed un intero M . Vogliamo trovare una sequenza 0/1 tale che

n∑i=1

wixi ≤M

3. BRANCH AND BOUND 25

e il profitton∑

i=1

pixi

sia massimo. Lo spazio delle soluzioni consiste di tutti i vettori binari con n componenti. Osserviamoche la soluzione ottima dello zaino intero ha un profitto che e certamente non maggiore del profittodella soluzione ottima dello zaino frazionario. Quindi se i valori di xi per i = 1, · · · , k sono stati giadeterminati un limite superiore si ottiene calcolando la soluzione ottima per il problema dello zaino incui la condizione xi ∈ 0, 1 e rilassata a xi ∈ [0, 1] per i = k + 1, · · · , n. Come e noto con il vincolodi interezza rilassato il problema dello zaino puo essere risolto efficientemente.

3. Branch and Bound

Primo di discutere di algoritmi branch-and-bound, introduciamo un ambito piu generale. Consi-deriamo un albero i cui nodi interni rappresentano soluzioni parziali e le foglie sono soluzioni. Tipica-mente i nodi foglia y corrisponderanno a soluzioni ammissibili e la soluzione e descritta dal camminodalla radice dell’albero alla foglia y. L’algoritmo riceve la radice dell’albero come input e, dato unnodo x, puo generare tutti i nodi figli di x. Progetteremo algoritmi branch-and-bound per due classidi problemi: ricerca di una foglia (soluzione ammissibile); ad ogni foglia y dell’albero e associato unvalore P (y) e ricerchiamo una foglia per cui P (y) e massimo (problemi di massimizzazione) o P (y) eminimo (problemi di minimizzazione).

Algoritmi branch-and-bound sono caratterizzati dal seguente criterio di espansione: un nodo restaE-nodo finche non muore (cioe tutti i suoi figli sono stati generati). Una volta che tutti i figli dell’E-nodo corrente sono stati generati, il prossimo E-nodo puo essere scelto in vari modi. Ad esempio, sescegliamo come prossimo E-nodo, il nodo vivo che e stato generato da piu tempo (disciplina FIFO)otteniamo una visita dell’albero per livelli; se invece scegliamo come prossimo E-nodo il nodo vivoche e stato generato da meno tempo (disciplina LIFO) otteniamo una visita dell’albero in profondita,simile alla modalita di visita del backtrack.

Un approccio piu generale consiste nell’assegnare ad ogni nodo vivo x un valore c(x) e sceglieread ogni passo come prossimo E-nodo, il nodo vivo con il valore c(x) piu piccolo. Otteniamo quindi ilseguente schema di algoritmo, dove T e la radice dell’albero che intendiamo esplorare e c e la funzioneche determina l’ordine di espansione dei nodi. Il campo P (X) contiene il puntatore al padre del nodoX ed e usato per stampare il cammino da una foglia alla radice.

BB(T, c)if T soluzione then

print T ;return;

Q← T;while (1)

if Q = ∅ thenprint Nessuna soluzione;

E ← ExtractMin(Q);if E soluzione then

print cammino da T a E;return;

foreach X child of EQ = Q ∪ X;P (X) = E;


Figura 2. Un’istanza per cui BB non restituisce la soluzione ottima.

Ad esempio, nel caso in cui e cercata una qualsiasi soluzione, c(x) potrebbe essere definito comela distanza dalla radice della piu vicina soluzione che si trova nell’albero radicato in x. Ovviamente,valutare c(·) su un nodo risulta essere tanto difficile quanto risolvere il problema stesso. Dobbiamopertanto accontentarci di una funzione c(·) che approsimi la funzione c. Tipicamente si sceglie unafunzione c(·) della forma

c(x) = f(h(x)) + g(x)ove h e la distanza di x dalla radice, f e una funzione non decrescente e g(x) e una stima della distanzadi x da una soluzione.

3.1. Il puzzle del 15. Il puzzle del 15 e un puzzle molto diffuso e si gioca su un riquadro 4 per4 con 15 tessere numerate che lasciano uno spazio vuoto. Il gioco consiste nel sistemare, partendoda una configurazione arbitrarie, le tessere numerate da 1 a 15 in ordine crescente. Le uniche mosseconsentite sono quelle di scambiare di posto lo spazio vuoto con una tessera numerata adiacente.

In questo caso ogni nodo dell’albero dello spazio delle soluzioni consiste in una configurazione(permutazione) delle tessere ed ha come figli le configurazione ottenibili effettuando una mossa. Perquesto problema un buon candidato per la funzione c e la funzione

h(x) + g(x)

ove h(x) e la profondita del nodo x e g(x) e il numero di tessere che si trovano fuori posto.

3.2. Branch and Bound per ottimizzazione. In questa sezione consideriamo problemi diminimizzazione. Iniziamo con il considerare una funzione c(x) che, per un nodo x dell’albero, restituisceil costo minimo di una soluzione presente nell’albero radicato in x. Ovviamente, in questo caso,l’algoritmo BB restituisce la foglia di costo minimo. Osserviamo pero che calcolare c(x) e tanto difficilequanto risolvere il problema input e pertanto dobbiamo accontentarci di una sua approssimazione c.Non tutte le funzioni c permettono di calcolare una foglia di costo mininmo: si veda l’esempio inFigura 2.

Ad esempio, se esistono due nodi x e y per cui abbiamo che c(x) < c(y) sebbene c(x) > c(y), alloraBB restituisce una foglia di valore non minimo. Proviamo ora che se nessuna “inversione” si verificaallora la ricerca BB una soluzione di costo minimo.

Teorema 5.1. Sia la funzione c tale che, per ogni x e y, c(y) < c(x) se e solo se c(y) < c(x).Allora la ricerca BB su un albero finito raggiunge un nodo di costo minimo.

Dimostrazione. E facile convincersi che la BB trova sempre una soluzione su un albero finito.Supponiamo invece che la ricerca BB restituisca una soluzione g di costo c(g) > c∗, ove c∗ e il costodi una soluzione ottima. Sia u l’antenato piu vicino a g il cui sottoalbero contiene una soluzione g∗ dicosto minimo e siano α1, · · · , αk e β1, · · · , βl i nodi che si trovano lungo il camino tra u e g∗ e u e g,rispettivamente. Per definizione di u, l’albero radicato in β1 non contiene nessuna soluzione di costoc∗.

Per definizione della funzione c abbiamo che

c(u) = c(α1) = c(α2) = · · · = c(αk) = c(g∗)

mentre invecec(β1), · · · , c(βl), c(g) > c(u).

Per la proprieta di c, cio implica che

c(α1), · · · , c(αk) > c(β1).

3. BRANCH AND BOUND 27

Pertanto β1 verra espaso dopo che α1, · · · , αk sono stati espasi e pertanto BB incontrera prima lasoluzione g∗.

3.3. Lower bounding. Il teorema precedente ci da una condizione sotto la quale la ricerca BBci conduce alla soluzione ottima. Purtroppo e difficile definire funzioni c che soddisfano la proprieta.Vedremo ora che infatti e sufficiente che la funzione c sia, per ogni x, un lower bound alla c(x).

Teorema 5.2. Sia c(x) ≤ c(x) per tutti i nodi e c(x) = c(x) per tutti i nodi soluzione. Allora laricerca BB resituisce sempre una soluzione di costo minimo.

Dimostrazione. Nel momento in cui viene trovata una soluzione E, abbimao che c(E) ≤ c(L)per tutti i nodi vivi L. Per assunzione c(E) = c(E) e c(L) ≤ c(L). Pertanto c(E) ≤ c(L) per tutti inodi vivi e quindi E e una soluzione di costo minimo.

3.4. Branch and bound per TSP. In questa sezione mostriamo come applicare la metodologiaBranch and Bound per risolvere il problema del commesso viaggiatore (TSP dall’inglese TravellingSalesperson Problem). Il problema consiste nel trovare in un grafo G il ciclo che visita tutti i vertici1, · · · , n di G una ed una sola volta e che ha costo (lunghezza) minima. Formalmente abbiamo.

Input: Una matrice delle distanze d tra gli n vertici. Il valore dij e la distanza tra il vertice i e ilvertice j.Sol. Ammissibili: una sequenza (x1, · · · , xn) tale che x1 = 1 e 1 ≤ i 6= j ≤ n implica xi 6= xj .Costo di sol. ammissibile:

C(x1, · · · , xn) =n−1∑i=1

dxi,xi+1 + dxn,x1 .

Per poter applicare la metodologia branch and bound dobbiamo definere i nodi degli alberi ed unafunzione c che soddisfa le ipotesi del Teorema 5.2. Un nodo dell’albero corrisponde ad una soluzioneparziale X = (x1, · · · , xk) in cui le k componenti sono distinte e x1 = 1. Se k 6= n, e quindi X none una foglia, allora X ha figli (x1, · · · , xk, xk+1) per ogni valore 1 ≤ xk+1 ≤ n che e differente dax1, · · · , xk. La radice corrisponde alla soluzione parziale X = (1).

Definiamo la funzione c nel modo seguente

c(x1, . . . , xk) =k−1∑i=1

dxi,xi+1 .

Abbiamo che c(X) ≤ c(X). Infatti, una qualsiasi soluzione ammissibile che si trova nell’albero radicatoin X corrisponde ad un ciclo C i cui primi k − 1 passi sono definiti da X. Pertanto il costo di C saraalmeno c(X).

Una differente funzione c e definita osservando che un ciclo che inizia con una soluzione parzialeX = (x1, · · · , xk) dovra certamente includere un arco da xk ad un vertice non ancora visitato. Quindiil costo un qualsiasi tale ciclo e certamente almeno

c = (x1, . . . , xk) =k−1∑i=1

dxi,xi+1 + min1≤y≤n:y 6=x1,...,xk

dxk,y.

Versione: 1.7 del 17 gennaio 2006.

CAPITOLO 6

NP-completezza

1. La classe P

Iniziamo con le seguenti semplici definizioni.

Definizione 6.1. Un linguaggio sull’alfabeto Σ e un sottoinsieme di Σ∗ (l’insieme delle stringhedi lunghezza finita su Σ).

Tipicamente, l’alfabeto Σ coincide con l’insieme 0, 1. La teoria dell’NP-completezza e le defini-zioni delle classi P e NP sono invarianti rispetto alla scelta dell’alfabeto purche questi contenga almenodue simboli.

Definizione 6.2. Un algoritmo A decide il linguaggio L se

A(x) = 1 se e solo se x ∈ L.

Definizione 6.3. Il linguaggio L appartiene alla classe P (in simboli L ∈ P) se esiste un algoritmoA tale che

(1) A decide L;(2) esistono una costante n0 ed una una costante c tali che per ogni x ∈ 0, 1∗ di lunghezza

almeno n0, A si ferma dopo al piu |x|c passi.

1.1. Esempi. E facile verificare che ciascuno dei seguenti linguaggi appartiene a P.(1) L = x|xha un numero pari di 0;(2) L = x|x e la rappresentazione binaria di una potenza di 2;(3) Il linguaggio L di tutte le quadruple (G, u, v, k) tali che

• G e la rappresentazione di un grafo (ad esempio, G e la matrice di adiacenza di un grafo).Per comodita, e con un piccolo abuso di notazione, indicheremo con G sia il grafo che lasua rappresentazione.• u e v sono due vertici di G che si trovano a distanza al piu k.

2. La classe NP

In questa sezione definiamo la classe di linguaggi NP. Informalmente un linguaggio L appartienealla classe NP, se e possibile verificare in tempo polinomiale l’appartenenza di una stringa x ad L.Formalmente abbiamo la seguente definizione.

Definizione 6.4. Un linguaggio L appartiene alla classe NP se esiste un algoritmo A(·, ·) tale che(1) esistono costanti n0 e c tale che per ogni x, y ∈ 0, 1∗ con |x| ≥ n0, A(x, y) si ferma in al

piu |x|c passi;(2) per ogni stringa x ∈ L esiste una stringa y ∈ 0, 1? tale che A(x, y) = 1;(3) per ogni x 6∈ L e per ogni y ∈ 0, 1?, A(x, y) = 0.

In altre parole se L ∈ NP allora per ogni x ∈ L esiste un certificato y di lunghezza polinomiale nellalunghezza di x che e “verificato” da A in tempo polinomiale e se x 6∈ L non esiste alcun certificato

29

30 6. NP-COMPLETEZZA

y. L’algoritmo A e anche chiamato algoritmo polinomiale di verifica. Nota che, poiche il tempo diesecuzione di A e polinomiale nella lunghezza del primo input, y ha a sua volta lunghezza polinomiale.

Consideriamo ad esempio il seguente linguaggio

Clique= (G, k)|G e un grafo che ha un sottografo completo di taglia k.Per provare che Clique∈ NP dobbiamo esibire un algoritmo polinomiale A che soddisfa la Definizio-ne 6.4.

Consideriamo il seguente algoritmo.A((G, k), (v1, · · · , vl))

01. if l 6= k then02. return 0;03. for i = 1 to k04. for j = i + 1 to k05. if vi = vj then06. return 0;07. for i = 1 to k08. for j = i + 1 to k09. if (vi, vj) non appartiene all’insieme degli archi di G then10. return 0;10. return 1;

L’algoritmo riceve una coppia (G, k) ed un certificato (v1, · · · , vl) per l’appartenenza di (G, k) allinguaggio Clique. L’algoritmo A verifica che il certificato consiste di k vertici (righe 01-02), chetutti i k vertici del certificato sono differenti (righe 03-06) e che i vertici del certificato costituisconoun sottografo completo di G (righe 07-10). Se tutte le verifiche hanno successo l’algoritmo restituisce1; altrimenti l’algoritmo restituisce 0. Osserviamo che se G ha un sottografo completo di taglia kcostituito dai vertici (v1, · · · , vk) allora l’algoritmo A con input (G, k) e (v1, · · · , vk) restituisce 1.Quindi la condizione 2 della Definizione 6.4 e soddisfatta.

Se invece G non ha nessun sottografo completo di taglia k allora per ogni sequenza di vertici(v1, · · · , vl) almeno una delle seguenti tre condizioni deve essere soddisfatta:

(1) l 6= k; in questo caso A restituisce 0 alla riga 02;(2) qualche vertice di G appare due volte nella lista; in questo caso A restituisce 0 alla riga 06;(3) i k vertici sono distinti ma per qualche coppia (i, j) l’arco (vi, vj) non e un arco di G; in

questo caso A restituisce 0 alla riga 10.Quindi se (G, k) 6∈Clique, non esiste nessun certificato per cui A restituisce in output il valore 1. Lacondizione 3 della Definizione 6.4 e pertanto soddisfatta.

Nel prossimo teorema proviamo che L ∈ P allora L ∈ NP.

Teorema 6.5. P ⊆ NP.

Dimostrazione. Sia L ∈ P. Allora esiste un algoritmo deterministico A che, su input x,restituisce 1 se e solo se x ∈ L. Si consideri il seguente algoritmo B.

B(x, y)01. return (A(x));

Osserviamo che se x ∈ L allora B(x, 0) = A(x) = 1 e quindi 0 e un certificato. Se invece x 6∈ L alloraper ogni possibile certificato y abbiamo che B(x, y) = A(x) = 0.

3. LA CLASSE NP − COMPLETE 31

Non e noto se P 6= NP. Sebbene la maggior parte degli studiosi creda che P 6= NP non abbiamoancora una prova. La Teoria dell’NP-completezza (che verra discussa nella prossima sezione) identificai linguaggi piu difficili di NP. Se almeno uno di essi ha un algoritmo polinomiale che lo decide alloraP = NP.

3. La classe NP− COMPLETE

Abbiamo le seguenti definizioni.

Definizione 6.6 (Riduzione). Sia L1 e L2 due linguaggi. Diciamo che L1 si riduce a L2 (insimboli L1 ≤p L2) se esiste un algoritmo polinomiale R tale che

R(x) ∈ L2 se e solo se x ∈ L1.

Definizione 6.7 (NP-completo). Un linguaggio L e NP-completo se(1) L ∈ NP;(2) per ogni linguaggio L′ ∈ NP abbiamo che L′ ≤p L.

Denotiamo con NP− COMPLETE la classe dei linguaggi NP-completi.

Si noti la similarita della definizione di linguaggio NP-completo con la definizione di massimo diun insieme I definito come quell’elemento x ∈ I tale che, per ogni y ∈ I, vale y ≤ x. La nozione dilinguaggio NP-completo esprime formalmente il concetto di linguaggio piu difficile di NP. Il seguenteteorema rafforza la nostra intuizione dicendoci che se un linguaggio NP-completo appartiene a P alloratutti i linguaggi in NP possono essere decisi in tempo polinomiale.

Teorema 6.8. Sia L un linguaggio NP-completo. Se L ∈ P allora P = NP.

Dimostrazione. Sia L′ un linguaggio in NP. Mostriamo un algoritmo polinomiale A′ che decideL′.

Poiche L ∈ P allora esiste un algoritmo polinomiale A che decide L. Inoltre, siccome L e NP-completo e L′ ∈ NP allora esiste un algoritmo polinomiale R che riduce L′ a L. Consideriamo ora ilseguente algoritmo A′

A′(x)01. y ← R(x);02. return (A(y));

Chiaramente l’algoritmo A′ e polinomiale. Supponiamo che x ∈ L′. Allora, per le proprieta dellariduzione R, y ∈ L e quindi A(y) = 1. Supponiamo ora che x 6∈ L′. Allora y 6∈ L e quindi A(y) = 0.Possiamo quindi concludere che A′ e polinomiale e decide L′ e quindi L′ ∈ P.

Un altro modo di leggere il teorema precedente e che se un linguaggio L e NP-completo allora L eda considerarsi “difficile”. Infatti se P 6= NP, allora non esiste alcuna algoritmo polinomiale che decideL.

Il prossimo teorema e particolarmente utile per provare che un linguaggio e NP-completo. Infatti,seguendo la definizione, per provare che un linguaggio L e NP-completo dobbiamo provare che ognilinguaggio in NP si riduce ad esso il che puo essere particolarmente difficile. Invece grazie al prossimoteorema bastera mostrare che un linguaggio NP-completo si riduce a L. Iniziamo con il provare ilseguente lemma.

Lemma 6.9 (Transitivita della relazione ≤p.). Sia L,L1 e L2 tre linguaggi tali che L2 ≤p L1 eL1 ≤p L. Allora L2 ≤p L.

Dimostrazione. Per ipotesi esistono due riduzioni polinomiali R1 e R2 tali che


• x ∈ L2 se e solo se R2(x) ∈ L1;• x ∈ L1 se e solo se R1(x) ∈ L.

Consideriamo il seguente algoritmo.

R(x)01. y1 ← R2(x);02. y ← R1(y1);03. return (y);

Per le proprieta degli algoritmi R1 e R2 abbiamo che se x ∈ L2 allora y1 ∈ L1 e quindi y ∈ L; inoltrese x 6∈ L2 allora y1 6∈ L1 e quindi y 6∈ L. Pertanto per l’algoritmo R vale la proprieta x ∈ L2 se e solose R(x) ∈ L. Inoltre l’algoritmo R e polinomiale e quindi abbiamo che L2 ≤p L.

Abbiamo quindi il seguente teorema.

Teorema 6.10. Sia L un linguaggio NP e sia L1 un linguaggio NP-completo tale che L1 ≤p L.Allora L e NP-completo.

Dimostrazione. Sia L2 un qualsiasi linguaggio NP. Allora L2 ≤p L1. Applicando il Lemma 6.9abbiamo che L2 ≤p L. Inoltre per ipotesi abbiamo che L ∈ NP e quindi L e NP-completo.

Grazie al Teorema 6.10, per provare che un linguaggio e NP-completo basta provare che un altrolinguaggio (che gia sappiamo essere NP-completo) si riduce ad esso. Abbiamo pero bisogno di unprimo linguaggio NP-completo da cui partire.

4. Il linguaggio CNFSAT

Una formula booleana Φ sulle variabili (x1, · · · , xn) e una formula che contiene i connettivi logici∧ (AND), ∨ (OR) e ¬ (NOT) e le variabili x1, · · · , xn. Indichiamo invece con il termine di letterale levariabili in forma negata e forma non negata. Ad esempio Φ = (((x1∧x2)∨(x1∧¬x3))∧(x1∨x4)) e unaformula booleana sulle variabili (x1, · · · , x4). Un assegnamento di verita t assegna ad ogni variabiledella formula Φ un valore booleano ed induce naturalmente un valore booleano t(Φ) della formula Φ.Ad esempio, l’assegnamento t tale che t(x1) = 0, t(x2) = 1, t(x3) = 1 e t(x4) = 0 rende la formulaformula Φ falsa (cioe t(Φ) = 0). Una formula Φ si dice soddisfattibile se esiste un assegnamento diverita t tale che t(Φ) = 1; in questo caso diciamo che t rende Φ vera. Definiamo il linguaggio SATcome il linguaggio che consiste delle formule booleane Φ che sono soddifacibili. Indichiamo invece conCNFSAT il linguaggio delle formule booleane in forma congiuntiva normale (AND di OR) che sonosoddifacibili. Ad esempio la formula Φ = (x1∨x2∨x3)∧(¬x1∨x2∨x4)∧(x2∨¬x4)∧(x2∨x3∨¬x4∨x5)e in formula congiuntiva normale e consiste di 4 clausole. La prima e la seconda clausola contengono3 letterali, la terza clausola contiene 2 letterali mentre la quarta clausola contiene 4 letterali.

Teorema 6.11. [Cook-Levin] Il linguaggio CNFSATe NP-completo.

5. Il linguaggio 3SAT

In questa sezione proviamo che il linguaggio 3SAT consistente di tutte le formule in forma con-giuntiva normale ove ogni clausola contiene esattamente 3 letterali e NP-completo.

Teorema 6.12. 3SAT∈ NP− COMPLETE.

Dimostrazione. Riduciamo CNFSAT a 3SAT e quindi, grazie al Teorema 6.10, otteniamo ilteorema.

Sia Φ una formula in forma CNF. Costruiamo in tempo polinomiale una formula Φ′ in forma 3CNF(cioe in forma CNF ove ogni clausola contiene esattamente 3 letterali) tale che Φ′ e soddisfattibile se

6. IL LINGUAGGIO Clique 33

e solo se Φ e soddisfattibile. La costruzione considera ogni clausola C di Φ separatamente e perognuna di esse costruisce una sequenza S di clausole. La sequenza S di clausole ha la proprieta cheun assegnamento di verita soddisfa C se e solo soddisfa S. La formula Φ′ e ottenuta legando insiemecon l’operatore ∧ tutte le clausole ottenute. Pertanto abbiamo che Φ′ e soddisfattibile se e solo se Φe soddisfattibile. La costruzione distingue i seguenti casi.

(1) La clausola C contiene un solo letterale a.In questo caso l’insieme S consiste delle seguenti clausole (a ∨ y1 ∨ y2) (a ∨ ¬y1 ∨ y2)

(a ∨ y1 ∨ ¬y2) (a ∨ y¬1 ∨ ¬y2).(2) La clausola C contiene due letterali (a1 ∨ a2).

In questo caso l’insieme S consiste delle seguenti clausole (a1 ∨ a2 ∨ y1) (a1 ∨ a2 ∨ ¬y1)(3) La clausola C contiene tre letterali (a1 ∨ a2 ∨ a3). In questo caso l’insieme S consiste della

sola clausola C.(4) La clausola C contiene k > 3 letterali (a1 ∨ a2 ∨ a3 ∨ · · · ∨ ak).

In questo caso l’insieme S consiste delle clausole(a1 ∨ a2 ∨ y1), (¬y1 ∨ a3 ∨ y2), . . . , (¬yk−3 ∨ ak−1 ∨ ak).

Consideriamo per esempio la formula

Φ = (x1 ∨ x2 ∨ x3) ∧ (¬x1 ∨ x2 ∨ x4) ∧ (x2 ∨ ¬x4) ∧ (x2 ∨ x3 ∨ ¬x4 ∨ x5).

La formula Φ′ ottenuta e la seguente

Φ′ = (x1∨x2∨x3)∧(¬x1∨x2∨x4)∧(x2∨¬x4∨y1)∧(x2∨¬x4∨¬y1)∧(x2∨x3∨y2)∧(¬y2∨¬x4∨x5).

6. Il linguaggio Clique

In questa sezione mostriamo che il linguaggio Clique e NP-completo mostrando una riduzione da3SAT.

Teorema 6.13. Clique∈ NP− COMPLETE.

Dimostrazione. Sia Φ una formula in forma CNF ove ogni clausola contiene esattamente 3letterali. Sia inoltre k il numero di clausole di Φ. La riduzione restituisce la coppia (G, k) ove il grafoG e costruito nel modo seguente. Il grafo G ha un vertice per ogni occorrenza di un letterale: Se illetterale xi appartiene alla j-esima clausola di Φ, il grafo G conterra il vertice v(i, j); diremo in questocaso che il vertice v(i, j) appartiene alla j-esima clausola. Se il letterale ¬xi appartiene alla j-esimaclausola di φ allora il grafo G conterra il vertice n(i, j); diremo in questo caso che il vertice n(i, j)appartiene alla j-esima clausola di φ. Ogni vertice di G ha un arco verso ogni altro vertice di G conle seguenti eccezioni:

(1) non ci sono archi tra vertici della stessa clausola;(2) non ci sono archi tra vertici corrispondenti ad un letterale ed al suo negato, anche se appar-

tengono a clausole differenti.Dimostriamo che Φ ∈ 3SAT se e solo se (G, k) ∈ Clique.(1) Supponiamo che Φ ∈ 3SAT.

Allora esiste un assegnamento di verita t tale che per ogni clausola esiste almeno unletterale vero. Consideriamo quindi k vertici (uno per clausola) di G corrispondenti a letteralidi Φ veri per l’assegnamento t e mostriamo che constituiscono una clique in G. Infatti, questik vertici appartengono a clausole differenti e non abbiamo tra questi vertici v(i, j) e n(i, j′)cossipondenti ad una variabile xi ed al suo negato ¬xi (altrimenti t non sarebbe un buonassegnamento di verita). Pertanto i k vertici costituiscono un sottografo completo di taglia ke quindi (G, k) ∈ Clique.


.................................................................................................................

....................

....................

....................

....................

....................

.............

.................................................................................................................................................................................................................................................................................

................................................................................................................................................................................................................................................................ ...........

.....................................................................................................................................................................................................................................................

Il gadget per la clausola (a ∨ b ∨ c)

Il gadget per il vero ed il falso Il gadget per la variable a

~~

~

~~

~ ~ ~~

~

~ ~

~

~~

V

X

F a ¬a

X

V

ba c

Figura 1. I tre gadget per la riduzione di 3SAT a 3Col.

(2) Supponiamo che (G, k) ∈ Clique.Allora esiste un sottografo completo C di k vertici in G. Per costruzione di G abbiamo

che(a) ogni vertice di C appartiene ad una differente clausola di Φ ed ogni clausola di Φ contiene

un vertice di C;(b) se v(i, j) appartiene a C allora certamente n(i, j′) non appartiene a C.Consideriamo quindi l’assegnamento di verita t che pone a vero tutti letterali corrispon-denti a vertici di C. L’assegnamento t e certamente legale per la proprieta (2b) e, per laproprieta (2a), soddisfa tutte le clausole di Φ. Quindi Φ ∈ 3SAT.

7. Il linguaggio 3Col

Il linguaggio 3Col consiste di tutti i grafi i cui vertici possono essere colorati usando 3 colori inmodo tale che due vertici adiacenti sono colorati con colori diversi. E facile verificare che 3Col ∈ NP.

Riduciamo 3SAT a 3Col usando i tre gadget descritti dalla Figura 1. In particolare la riduzioneper la formula Φ sulle variabile x1, · · · , xn costruisce un grafo che contiene:

(1) un gadget per il vero e falso;(2) un gadget per ciascuno delle variabile; nota che i gadget delle variabili condividono il vertice

X con il gadget per il vero e il falso;

8. ESERCIZI 35

(3) un gadget per ogni clausola; nota che il gadget per la clausola (a ∨ b ∨ c) condivide il verticea con il gadget della variabile a, il vertice b con il gadget della variabile b, il vertice c con ilgadget della variabile c ed il vertice V con il gadget per il vero e falso.

Notiamo che il gadget per le variabili impone che i vertici a e ¬a devono essere colorati uno con V eduno con F. Possiamo inoltre verificare che se i tre vertici dei letterali di una clausola C sono coloraticon F allora non e possibile colorare i restanti vertici del gadget di C. Se invece almeno uno di essi ecolorato con V allora e possibile completare la colorazione del gadget di C. Abbiamo quindi il seguente

Teorema 6.14. 3Col ∈ NP− COMPLETE.

8. Esercizi

Esercizio 6.15. Se L e un linguaggio, definiamo L (il complemento di L) come la differenzasimmetrica

L = Σ∗ \ L.

Provare che se L ∈ P allora L ∈ P .

Esercizio 6.16. Denotiamo con co-NP la classe dei linguaggi L tali che L ∈ NP. Provare che seNP 6= co-NP allora P 6= NP.

Esercizio 6.17. Sia L1, L2 ∈ NP. Provare che L1 ∪ L2 e L1 ∩ L2 sono entrambi in NP.

Esercizio 6.18. Sia L un linguaggio. Definiamo il linguaggio L? come il linguaggio di tutte lestringhe w tali che esistono w1, · · · , wk per cui

(1) w = w1 · · · wk (“” denota la concatenazione di stringhe);(2) w1, · · · , wk ∈ L;

Provare che se L ∈ NP allora L? ∈ NP.

Esercizio 6.19. Usando la notazione dell’esercizio precedente, provare che se L ∈ P allora L? ∈ P .

Esercizio 6.20. Si consideri il linguaggio Hamilton dei grafi hamiltoniani. Un grafo e dettohamiltoniano se esiste un cammino che visita tutti i vertici una sola volta. Provare che Hamilton∈NP.

Esercizio 6.21. Provare l’equivalenza tra il problema decisionale e il problema di ricerca per illinguaggio Clique.

Esercizio 6.22. Supponiamo che esista un oracolo O per decidere il linguaggio NP-completo L.Provare che esiste un algoritmo polinomiale che usa O come oracolo, effettua un numero polinomialedi chiamate ad O e risolve il problema di ricerca associato ad L.

Esercizio 6.23. Abbiamo un trasmettitore che vuole inviare un messaggio ad un insieme D =d1, · · · , dm di m destinazioni. Il trasmettitore e collegato ad n coppie di ripetitori (ai, bi), i = 1, · · · , ned ogni ripetitore ai (rispettivamente bi) e collegato ad un sottoinsieme Ai (rispettivamente Bi) didestinazioni. Per evitare interferenze per ogni coppia di ripetitori (ai, bi) possiamo avere esattamenteun solo ripetitore attivo. Diciamo che e possibile trasmettere il messaggio se esiste un modo di attivarei ripetitori in modo tale che per ogni coppia solo un ripetitore e attivo ed ogni destinazione e adiacentead almeno un ripetitore attivo.

Provare che decidere se una trasmisisone e possibile e NP-completo.

Esercizio 6.24. Provare che il problema di determinare se una formula Φ in forma congiuntivanormale con esattamente 3 letterali per clausola ammette un assegnamento di verita tale che per ogniclausola esistono almeno due letterali veri e decidibile in tempo polinomiale.


Esercizio 6.25. Provare che il problema di determinare se una formula Φ in forma congiuntivanormale con esattamente 3 letterali per clausola e dove ogni letterale compare esattamente 3 volteammette un assegnamento di verita che la soddisfa e decidibile in tempo polinomiale.

Esercizio 6.26. Abbiamo provato che Max2SAT e completo. Questo non significa che Max2SATe difficile per tutte le classi di input.

Provare che e possibile decidere in tempo polinomiale se (Φ,m − 1) ∈ Max2SAT, dove m e ilnumero di clausole di Φ. Estendere questo risultato al caso (Φ,m− c) per ogni costante c > 0.

Esercizio 6.27. Un monomio e un AND di letterali. Una formula e in forma disgiuntiva normale(DNF in breve) se e un OR di monomi. Ad esempio la seguente formula e in forma DNF Φ =(x1 ∧ x2 ∧ x3) ∨ (¬x1 ∧ ¬x2 ∧ x4).

Definiamo il linguaggio DNFSAT come il linguaggio delle formule in DNF che sono soddisfattibili.Provare che DNFSAT ∈ P.

Esercizio 6.28. Data una formula in 3CNF possiamo usare la legge distributiva per construireuna formula equivalente in DNF. Ad esempio abbiamo che

(x1 ∨ x2 ∨ ¬x3) ∧ (¬x1 ∨ ¬x2) ≡ (x1 ∧ ¬x1) ∨ (x1 ∧ ¬x2) ∨ (x2 ∧ ¬x1) ∨ (¬x3 ∧ ¬x1) ∨ (¬x3 ∧ ¬x2).

Poiche abbiamo visto che DNFSAT∈ P (Esercizio 6.27) abbiamo che P = NP. Dove e l’errore?

Note bibliografiche

La teoria dell’NP-completezza e stata introdotta da S. Cook in [2] (che ha provato che il linguaggiodelle formule in forma disgiuntiva normale che non sono una tautologia e completo) e da L. Levin in[5] (che ha provato la completezza di diversi linguaggi). La prova dell’NP-completezza di Clique e deiGrafi di Hamilton e stata data da Karp [4]. Il libro di Garey e Johnson [3] e un’ottima guida allateoria dell’NP-completezza.

Versione: 1.39 del 17 gennaio 2006.

Bibliografia

[1] M. Blum, R. Floyd, V. Pratt, R. Rivest, and R. Tarjan. Time bounds for selection. Journal of Computer and SystemSciences, 7(4):448–461, 1972.

[2] Stephen A. Cook. The complexity of theorem-proving procedures. In Proceedings of the third annual ACM symposiumon Theory of computing, pages 151–158. ACM Press, 1971.

[3] M.R. Garey and D.S. Johnson. Computers and Intractability. Freeman, 1979.[4] R. M. Karp. Reducibility among combinatorial problems. Complexity of Computer Computations, pages 85–103, 1972.[5] L. Levin. Universal sequential search problems. Problemy Peredachi Informatsii, 9(3):265–266, 1973.[6] V. Strassen. Gaussian elimination is not optimal. Numerische Mathematik, 14(3):354–356, 1969.

37

algoritmi e strutture dati--lecture...

Documents