Partizioni intere

Partizioni intere
PARTIZIONAMENTO: Dato un insieme di n interi non negativi rappresentati in binario,
trovare un sottoinsieme
P ! {1,2,..., n } tale che
!i"P ai = !i# P ai
Es: Dato {38, 17, 52, 61, 21, 88, 25} possiamo rispondere positivamente al quesito poiché
38+ 52 +61 = 17 + 21 + 88 + 25 = 151
Supposto quindi che la somma di tutti gli interi sia pari (se la somma è dispari non si ha
soluzione) si determina il valore H = 1/2 !a .
i
Per ciascun i, 0 ! i ! n si determina un insieme numerico B(i) definito come
B( i ) = {b ! H: b è la somma di qualche sottoinsieme dei numeri a1, a2, ...., an}.
In altre parole si determinano tanti sottoinsiemi B(i) quanti sono gli elementi
E’ chiaro che una volta computato B( n ) se H " B( n ) il partizionamento è possibile.
Partizioni intere cont.
l’algoritmo per la costruzione dei B( i ) è il seguente
B(0) := {0}
for i =1,2, ..., n do
" B(i) := B( i-1 );
for j = ai, ai+1, ai+2 ...., H do
{38, 17, 52, 61, 21, 88, 25}
if j - ai " B( i -1 ) then B( i ) := B( i ) ${ j }
B(0) = {0}
B(1) = {0,38}
B(2) =
B(3) =
B(4) =
B(5) =
B(6) =
[ai =38, ai +1=39 ,....., ai +113=151 ]
{0,17,38,55}
{0,17,38,52,55,69,90,107}
{0,17,38,52,55,61,69,78,90,107,113,116,130,151}
{0,17,21,38,52,55,59,61,69,73,76,78,82,90,99,107,111,113,116,128,130,134,137,151}
{0,17,21,38,52,55,59,61,69,73,76,78,82,88,90,99,105,107,109,111,113,116,126,128,130,
134,137,140,143,147,149,151}
B(7) = {0,17,21,25,38,42,46,52,55,59,61,63,69,73,76,77,78,80,82,84, 86, 88,90,94, 98,99,101,103,
105,107,109,111,113,115,116,124,126,128,130,132,134,136,137,138,140,141,
143,147,149,151}
Considerazioni sulla codifica dei problemi
L’esempio visto sul partizionamento conduce ad una riflessione sulle modalità di
codifica dei singoli problemi.
Si consideri infatti la seguente variante del problema di partizionamento
PARTIZIONAMENTO: Dato un insieme di n interi non negativi rappresentati in
notazione unaria, trovare un sottoinsieme
P ! {1,2,..., n } tale che
!i"P ai = !i# P ai
La complessità dell’algoritmo visto in precedenza risulta O(nH) che apparentemente
sembra di tipo lineare nella lunghezza n dell’input.
Un’analisi più dettagliata porta tuttavia a dei risultati profondamenti diversi per i due
problemi di partizionamento enunciati.
1. Rappresentazione binaria degli interi - Avendo rappresentato gli interi in notazione
binaria la loro somma crescerà in modo esponenziale rispetto alla lunghezza dell’input.
Es. se gli n numeri di una istanza sono dell’ordine di 2n vuol dire che H # (n/2) 2n
mentre evidentemente la lunghezza dell’input è solo O(n2).
2. Rappresentazione unaria degli interi - Poiché l’input è di lunghezza circa H La
valutazione O(nH) diventa lineare, quindi efficiente.
Ancora sulla codifica dei problemi
Per rendere le cose più chiare si consideri il seguente semplice algoritmo che
considera come input l’intero k:
ALGORITMO (k)
for i:= 1 to k do
t:= t+1;
La complesità dell’algoritmo è certamente $ (k) possiamo ancora chiederci se esso ha una
valutazione polinomiale sulla dimensione dell’input.
Una rappresentazione binaria dell’intero k ci porta a dire che la dimensione dell’input è
log 2 k
)
log 2 k per cui la complessità asintotica dell’algoritmo sarebbe $ (k) = $ ( 2
ovvero esponenziale nella dimensione dell’input.
Se di dovesse rappresentare l’intero k in notazione unaria, cioé con una serie di k
111.....1. Poiché l’input è di lunghezza k la valutazione dell’algoritmo sarebbe $ (k)
ovvero lineare, quindi efficiente!.
Come si spiega questo paradosso?
E’ chiaro che la rappresentazione binaria dell’input cattura la intrinseca difficoltà del
problema contrariamente alla codifica unaria.
Schemi di codifica
Dato un Problema P con le sue istanze IP e dato un alfabeto T, si definisce come schema
di codifica di P una funzione EN: IP % T* che mappa ogni istanza di P in una
corrispondente stringa di T*.
Uno schema di codifica è ragionevole se aderisce in modo naturale al problema sotto
considerazione (non si devono creare sequenze artificiosamente lunghe).
Cio’ significa, ad esempio:
- I valori numerici vengono codificati in base % 2
- Gli insiemi vengono codificati mediante enumerazione delle codifiche dei loro elementi
- Le relazioni e le funzioni vengono codificate per enumerazione dei loro elementi (coppie, n-ple).
- I grafi vengono rappresentati come coppie di insiemi (di nodi e di archi)
Per gli schemi di codifica ragionevoli vale la condizione di essere tra di loro
correlati polinomialmente
Il problema della soddisfacibilità
Sia U ={a1, a2, a3,....am} un insieme di variabili booleane. Una funzione di assegnamento della
verità per U è una funzione t: U % {T, F} definita nel seguente modo:
"
se t( a ) = T si dice che a è vera rispetto a t
se t( a ) = F si dice che a è falsa rispetto a t
Si dice Letterale una qualunque variabile a, " su U pertanto:
il letterale a è vero sse a è vero rispetto a t
il letterale " è vero sse a è falso rispetto a t
Si definisce clausola una disgiunzione di letterali
Es:
C= a1 & "2 & a3 è una clausola che risulta vera se è vera almeno uno dei suoi componenti
mentre risulta falsa per l’assegnazione t (a1) = F, t (a2) = T, t (a3) = F.
Una formula booleana in forma normale congiuntiva è la congiunzione di un insieme di clausole
Es:
S = {C1,C2,C3} = {(a1 & "2 & a3), ("1 ), (a2 & "2 ) } = (a1 & "2 & a3)' ("1 )' (a2 & "2 )
Il problema della soddisfacibilità cont.
Data una formula booleana S in forma normale congiuntiva si dirà che un assegnamento di
valori di verità t soddisfa S se per ogni clausola C " S esiste almeno una variabile a tale che o
i
"
t( ai ) = T e ai " C oppure t( ai ) = F e "i " C
Esempio 1.
S = {(a & " & a ), (" ), (a & " ) }
1
2
3
1
2
2
l’assegnamento t (a1 ) = F , t (a2 ) = T, t (a3 ) = T soddisfa la formula data,
mentre ad esempio l’assegnamento t (a1 ) = T , t (a2 ) = T, t (a3 ) = T non soddisfa la formula.
Definizione: Si dice che la formula S è soddisfacibile se esiste un’assegnazione di valori che la
soddisfi
Esempio 2:
S’ = {(a1 & a2), (a1 & "2 ), ("1 )}
S’ non è soddisfacibile poiché non esiste alcuna assegnazione che renda vera la formula
SODDISFACIBILITA’ (SAT): Data una formula booleana S in forma normale congiuntiva
decidere se la formula S è soddisfacibile per qualche assegnazione di valori di verità alle
variabili in essa contenute.
2-SAT
E’ una caso particolare del problema della soddisfacibilità in quanto ogni clasusola contiene al
più due letterali. Si dimostra che l’algoritmo per 2-SAT è polinomiale.
prima fase
Si opera sulle clausole con letterali singoli, si assegna un valore di verità e si semplificano
le altre clausole in relazione a tale assegnazione
a1 & a2
a3 & "2
a3 & "2
a1
"1 & "2
t(a1 ) = T
"2
a3 & a4
a3 & a4
"3 & a5
"4 & "5
"3 & a5
"4 & "5
a4 & "3
a4 & "3
t(a2 ) = F
a3 & a4
"3 & a5
"4 & "5
a4 & "3
Oss. al primo passo si toglie dalla quarta clausola anche "1 in quanto questo letterale
risultando falso non contribuisce al soddisfacimento della clausola
2-SAT
seconda fase
Tutte le clausole hanno ora due letterali. Per una qualche variabile cui non è stato assegnato un
valore di verità si fa l’assegnazione T/F e si opera con una semplificazione. Se non si arriva a
contraddizione si procede sul nuovo set di clausole altrimenti ci si ferma con fallimento.
a &a
3
4
"3 & a5
t(a3 ) = T
"4 & "5
"4 & "5
a4 & "3
"4 & "5
a4
a &"
4
3
a3 & a4
"3 & a5
a5
t(a5 ) = T
"4
a4
t(a4 ) = T
"5
a5
a
t(a ) = F
3
4
"4 & "5
t(a4 ) = T
contraddizione
contraddizione
t(a5 ) = F
"
5
successo
-
L’assegnazione risultante è perciò t(a1) = T, t(a2 ) = F, t(a3 ) = F, t(a4 ) = T, t(a5 ) = F
La complessità dell’algoritmo è polinomiale: ciascuna operazione di semplificazione è polinomiale e non ci
sono più di due semplificazioni per variabile (al caso di contraddizione si arriva in un solo passo).
Ancora su 2-SAT
Qualsiasi clausola a & a può essere pensata come una coppia di implicazioni
1
2
# #
"1% a2 e "2% a1
Il caso di letterale singolo a viene considerato come "% a
Partendo da una istanza di 2-SAT si può costruire un grafo diretto avente per nodi tutti i
letterali dell’istanza e come archi l’implicazione.
Teorema:Una istanza di 2-SAT è insoddisfacibile se e solo se esiste un percorso da a ad " e
da " ad a per ogni letterale della formula.
Dalla verifica indotta dal teorema scaturisce il fatto che 2-SAT è proprio un problema
risolvibile polinomialmente.
Esercizio 1
Verificare col metodo indicato che l’esempio 2
"
"
S’ = {(a1 & a2), (a1 & "2 ), ("1 )}
è insoddisfacibile"
"
Esercizio 2
Verificare se la formula
"
"
S = {(a1 & a2), (a1 & "3 ), (a2 & a4), (a3 & "4 )}
è o no insoddisfacibile""
La classe NP
Una Macchina di Turing M non deterministica è detta polinomialmente limitata se
esiste un polinomio P tale che per ogni input x non esistono configurazioni C di M
raggiungibili in P(|x|)+1 passi.
Si definisce con NP (Nondeterministic Polynomial) la classe dei linguaggi che sono
decisi in tempo polinomiale da una macchina di Turing non deterministica.
Esempi di problemi in NP:
SODDISFACIBILITA’
CICLI HAMILTONIANI
COMMESSO VIAGGIATORE
INSIEMI INDIPENDENTI
CRICCA
RICOPRIMENTO DI NODI
.............
...........
SAT è in NP
Si costruisce una Macchina di Turing Non Deterministica che opera nel seguente modo:
1. Conteggio delle variabili- Dato l’input w viene dapprima controllato se la formula è legale
! (se non lo è la formula viene rigettata). Vengono quindi contate le variabili che compaiono in
! essa e si ricopia sul secondo nastro una stringa di sbarre in numero pari alle variabili nella
! formula. [Questa fase è deterministica]
2. Generazione degli assegnamenti - Sul nastro 2 vengono riscritti in sovrapposizione ai
! caratteri | le condizioni T o F. La sequenza viene definita in modo non deterministico, questo
! viene ottenuto aggiungendo a K un’apposito stato q e a ! transizioni del tipo
!(q , |)= (q,T, f)
[non determinismo]
! (q, |)= (q, F, f)
!(q ,T)= (q , T, d),
!(q , F) = (q , F, d)
!(q, ")= (q’, ", f )
dove q’ è lo stato che continua la computazione e f e d indicano il movimento della testina.
3. Verifica degli assegnamenti - La stringa di {T,F}n viene interpretata come assegnamento per la
! formula contenuta nel primo nastro. Controllando se in ciascuna clausola esiste un
! assegnamento di verità. Se questo si verifica l’assegnazione è valida e la macchina accetta,
! altrimenti rigetta l’assegnazione. [Anche questa fase è deterministica]
Definizione alternativa dei problemi in NP
L’algoritmo prima visto suggerisce una caratterizzazione che è tipica dei soli problemi in NP
Siamo infatti partiti dalla generazione (non deterministica) di una possibile soluzione al
problema e quindi siamo passati nel passo successivo alla “verifica” della soluzione.
Questo schema può essere generalizzabile ad ogni problema (linguaggio) in NP. Infatti
possiamo informalmente dire che un linguaggio L appartiene alla classe NP se è possibile
“verificare” in tempo polinomiale l’appartenenza di una stringa ad L. Più formalmente:
Def. Un linguaggio L appartiene alla classe NP se e solo se esiste un algoritmo di verifica A
tale che:
1. Esistono due costanti c ed n0 tale che per ogni x,y # {0,1}* con | x | $ n0 A(x,y) si ferma in
! al più | x | c passi ;
2. Per ogni stringa x # L esiste una stringa y tale che A(x,y) = Yes
3. Per ogni stringa x % L, e per ogni stringa y, A(x,y) = No
In altri termini l’appartenenza del linguaggio L alla classe NP implica che per ogni stringa x # L
esiste una stringa y di lunghezza polinomiale nella lunghezza di x che è “verificato” in tempo
polinomiale dall’algoritmo A, e se x % L non esiste alcuna stringa y.