Curs 6 - Agendadlucanu/cursuri/ap/resurse/curs6.pdf · colorarea grafurilor submultimea de suma maxima Programare dinamica prezentare distanta dintre siruri. Dorel Lucanu Algoritmica

Dorel Lucanu Algoritmica si programare

Curs 6 - Agenda

Algoritmi de enumerare si paradigma"backtracking"

"backtracking“ – prezentare generalaalgoritmi de enumerare"backtracking“ – algoritmiStudii de caz

problema celor n reginecolorarea grafurilorsubmultimea de suma maxima

Programare dinamicaprezentaredistanta dintre siruri


"Backtracking“: cadru general

metoda de rezolvare: cautare in spatiulsolutiilor candidat (finit)cautare exhaustiva: este cercetat intregulspatiu"backtracking“ = cautare sistematicaspatiul solutiilor este organizat ca un arbore

un varf este viabil daca sunt sanse sa se gaseasca o solutie explorand subarborelecu radacina in acel varfsunt explorati numai subarborii cu radaciniviabile"backtracking" exploreaza lista varfurilorviabile din arbore utilizand DFS


"Backtracking": ingrediente

spatiul solutiilor candidat organizat ca arboreprodus carteziansubmultimipermutaridrumuri in grafetc

se defineste o functie criteriu prin care se stabileste daca un varf este viabil sau nuarborele este explorat prin algoritmul DFS

fie x = (x0, ..., xk) secventa care descriedrumul de la radacina la varful curentdaca varful curent este pe frontiera se verifica daca x este solutiein caz contrar se alege urmatorul succesorviabil (daca exista)


"Backtracking" pentru probleme de minim

problema: calculul lui minx f(x)presupunere:

f(x1,...,xk-1, xk) = f(x1,...,xk-1) + g(xk)cu g(xk) > 0se pleaca cu un minim initialdaca varful curent este pe frontiera se verifica daca f(x) este mai mic decat minimulcalculat pana in acel moment

daca da, atunci f(x) devine noul minimdaca varful curent NU este pe frontiera si f() calculat pentru solutia partiala este mai mare decat minimul calculat pana in acel moment, atunci varful nu este viabil si este abandonat


Spatiul solutiilor = produs cartezian

S = {1,2,3} × {1,2}

1

1 2

(1,1) (1,2)

1 2

(2,1) (2,2)

1 2

(3,1) (3,2)

2 3

dimensiune spatiu: A0 × A1 × ... × An-1 are |A0| × |A1| × ... × |An-1| elemente


Enumerarea elementelor din {0,...,m-1}n

procedure EnumProdCart(m,n)begin

k ← 0; x[0] ← -1while (k >= 0) do

if (x[k] < m-1)then x[k]++

if (k=n-1) then scrie(x)else k++

x[k] ← -1else k--

end


Produs cartezian – algoritm recursiv

procedure enumProdCartRec(x, k)for j ← 0 to m-1 dox[k ← jif (k = n-1)

then scrieElement(x, n)else enumProdCartRec(x, k+1)

end


Spatiul solutiilor = submultimi

S ⊆ {0, 1, ..., n-1}S poate fi reprezentata prin vectorul saucaracteristic x:x[i] ∈ {0,1}, x[i] = 1 ⇔ i ∈ Svector caracteristic ∈ {0,1}n

enumerare submultimi = enumerare vectoricaracteristicidimensiune spatiu: 2n


Spatiul solutiilor = submultimi: exemplu

0 1 0 1 0 1 0 1

0

0

01 1

1

∅ {2} {1} {1,2}


Spatiul solutiilor = permutari

enumerare permutari prin "bactracking"x[k] viabil ⇔ 0 ≤ x[k] ≤ n-1 si

x[k] ≠ x[i] pentru i = 0, ..., k-1

2 1

1 2

2 0

0 2

1 0

0 1

0 1 2n = 3:

0 1 2 0 2 1 1 0 2 1 2 0 2 0 1 2 1 0



o alta reprezentare

(0)

(0,1) (1,0)

(2,1,0)(1,2,0)(1,0,2)(2,0,1)(0,2,1)(0,1,2)



o alta reprezentare – recursiv

procedure enumPermRec(p, k)if (k = n-1)then scriePerm(p,n)else p[k] ← k

for i ← k-1 downto 0 doenumPermRec(p,k+1)swap(p[i+1],p[i])

enumPermRec(p,k+1)end


Spatiul solutiilor = permutario alta reprezentare – nerecursiv

procedure enumPerm(n)k ← 0S[0] ← 0while (k >= 0) do

if (S[k] >= 0)then f(k, S[k], p)

S[k-1] ← S[k-1]-1if (k = n-1)

then scriePerm(p,n)else k ← k+1

S[k] ← kelse aux ← p[0]

for i ← 0 to k-1 dop[i] ← p[i+1]

p[k] ← auxk ← k-1

end



function f(k, i, p)if (i = k)then p[k] ← kelse aux ← p[i+1]

p[i+1] ← p[i]p[i] ← aux

end


Spatiul solutiilor = drumuri in graf cu sursa data

0

1 2

3

4

0

1 4

2 3

2 43

4

3

1 2

2 1

se parcurge DFSori de cate ori se epuizeaza lista de asteptare a lui i ≠ i0 se face p[i] = a[i] (se

reia de la capat)se inlocuieste testul i ∈ S cu i ∈ stiva


Drumuri in graf cu sursa si destintatia precizate

lista de adiacenta = parcurgerea in sensularcelor de ceasornic incepind cu vecinul din dreaptase parcurge DFS incepand cu (0, 0)ori de cate ori se intalneste (1,2) stiva descrieun drum de la (0,0) la (1,2)

(1,1)

(0,0) (0,1) (0,2)

(1,0) (1,2) (1,1)

(0,2)

(1,1)

(0,0)

(0,1)

(0,2)

(1,2)(1,2)

(1,0)

(1,2)

(1,2)

(0,1)(1,0)

sursa

dest.


Spatiul solutiilor = labirint

5

4

3

2

1

0

3210

0110

0000

0101

0001

1101

1100

(0,0)

(5,3)

lista de adiacenta = parcurgerea in sensul arcelorde ceasornic incepind cu vecinul din dreapta


Backtracking – algoritm nerecursiv

procedure backtracking(n)k ← 0while (k >= 0) do

if ((exista y in T(x[0..k]) neincercat) and(viabil(y)))

then x[k+1] ← yif (x[0..k+1] = solutie)then scrie(x)else k ← k+1

else k ← k-1end

T(x[0..k]) multimea tuturor valorilor posibile pentrux[k+1]


Backtracking – algoritm recursiv

procedure backtrackingRec(x, k)forall y in T(x[0..k]) neincercat

and viabil(y) dox[k+1] ← yif (x[0..k+1] = solutie)then scrie(x)else backtrackingRec(x, k+1)

end


Backtracking – instantiere produs cartezian

procedure backtrack(n, m)k ← 0x[0] ← -1while (k >= 0) do

if (x[k] < m-1)then repeat

x[k] ← x[k]+1until(viabil(x, k) or (x[k]=m-1))if (viabil(x, k))then if ((k = n-1) and ST(x))

then scrieElement(x,n)else k ← k+1

x[k] ← -1else k ← k-1

end


Backtracking – instantiere produs cartezian

procedure backtrackRec(x, k)for j ← 0 to m-1 do

x[k] ← jif ((k = n-1) and (ST(x))then scrieElement(x, n)else if (viabil(x, k))

then backtrackRec(x, k+1)end


Backtracking: problema celor n regine

Problemaintrare: o tabla de sah n × n, n regineiesire: toate asezarile posibile ale celor n

regine pe tabla fara ca sa se atace

0 21 30

1

2

3


Problema celor n regine: algoritm bk

reprezentarea solutieio reprezentare care nu-i OKQ[i,j] = true ⇔ pe pozitia [i,j] se gaseste o

reginanr. sol. candidat = 2n×n

o reprezentare mai bunas[i] = j ⇔ Q[i,j] = truenr. sol. candidat = nn

n = 8 ⇒ 2n×n = 264 , nn = 224

criteriul de viabilitate(∀i) 0 ≤ i ≤ k – 1 ⇒ s[i] ≠ s[k] ∧ |s[i] – s[k]| ≠ |i-k|


Problema celor n regine: arborele taiat

0 1 2 3

2 3

1 0 3

3 0

2 1

0 1

2

0 21 30123

xx

xx

x

xx

x


Backtracking: colorarea grafurilor

problemainstanta

un graf G = (V, E), V = {0, ..., n-1}, m culori 1, 2, ..., mcolorare c : V → {1, 2, ..., m}, {i, j} ∈ E ⇒ c[i] ≠ c[j]

iesire:toate colorarile posibile

modelul matematicreprezentarea solutiilor

c ∈ {1, 2, ...,m}n

criteriul de viabilitate(∀j) 0 ≤ j < k and {j, k} ∈ E ⇒ c[j] ≠ c[k]


Backtracking: submultimi de suma data

problemainstanta

o multime A cu n elementefiecare a ∈ A are o marime s[a] ∈ Z+

un numar M ∈ Z+

iesiresubmultimile A’ ⊆ A cu ∑(s[a] a ∈ A’) = M


Backtracking: submultimi de suma data

modelul matematicreprezentarea solutiei

pp. A = {0, 1, ..., n-1}, s[i] = wi

A' reprezentata prin vectorul caracteristic xcriteriul de viabilitate:

∑i=1,k xi⋅wi ≤ M si∑i=1,k xi⋅wi + ∑i=k+1,n wi ≥ M


Programare dinamica - prezentare

probleme de optimdefinirea subproblemei (stare) si asocierea functiiobiectiv pentru subproblemadefinirea unei relatii de tranzitie intre stari (decizie)politica = secventa de deciziiaplicarea Principiului de Optim pentru obtine relatia de recurentaPrincipiul de Optim (PO): o subpolitica a unei

politici optimale este la rindul ei optimalacalculul recurentei rezolvind subproblemele de la mic la mare si memorind valorile date de relatiade recurenta intr-un tablouextragerea solutiei optime din tablou


Distanta intre siruri – problema

instantadoua siruri a si b de lungime nasupra lui a se pot face operatiile:

modificare: M(i, c)stergere: S(i)inserare: I(i, c)

iesireo secventa de operatii de lungime minima care transforma sirul a in b

exemplua = “armata”, b = “camara”“armata” → “amata” → “camata” → “camara”d[“armata”, “camara”] = 3


Distanta intre siruri – propretati

ordinea operatiilor intr-o secventa optima nu are importanta

“armata” → “amata” → “camata” → “camara”“armata” → “amata” → “amara” → “camara”“armata” → “carmata” → “camata” → “camara”“armata” → “carmata” → “carmara” → “camara”“armata” → “armara” → “amara” → “camara”“armata” → “armara” → “carmara” → “camara”


Distanta intre siruri – propretati (cont.)

exista o secventa optima in care sirurileintermediare au lungimea ≤ nd[a,b] este o metrica:

d[a, a] = 0d[a, b] = d[b, a]d[a, c] ≤ d[a, b] + d[b, c]


Distanta intre siruri – model

stare: DES[i,j] = determinarea distantei minimeintre subsirurile de lungime i si respectiv jvaloarea asociata unei stari: [i,j]functia asociata unei stari: d[i, j] = d[a[1..i], b[1..j]]decizie:

presupunem ca b[j] se obtine prin stergere:DES[i,j] → DES[i-1, j]presupunem ca b[j] se obtine prin modificare:DES[i,j] → DES[i-1, j-1]presupunem ca a[i] se obtine prin inserare:DES[i,j] → DES[i, j-1]


Distanta intre siruri – model (cont.)

relatia de recurentad[0, j] = j, d[i, 0] = i (∀i, j)d[i, j] = min{d[i-1, j] + 1,

d[i-1, j-1] + δ[i, j], d[i, j-1] + 1}

δ[i, j] = if (a[i] = b[j]) then 0 else 1

timp:calculului matricii d: O(n2)determinarea secventei de operatii: O(n)

spatiu: O(n2)


Distanta intre siruri - exemplu

3

3

2

2

2

1

10

a

t

a

m

r

a

aramac

445566

434455

433344

443333

433222

543211

65432

( )M(5,’r’), S(2), I(1,’c’)


Programare dinamica – prezentare formala

Modelul matematicprobleme de optim

functia obiectiv: optim R(x1, ..., xn)restrictii: g(x1, ..., xn) ? 0

stare = subproblemadecizie: d: s → s’unei stari s asociem o valoare z si o functief(z) a.i. daca s corespunde starii initialeatunci f(z) = optim R(x1, ..., xn)

politica: d1: s0 → s1, d2: s1 → s2, . . . , dn: sn-1 → sn,


Programare dinamica – prezentare formala

PO conduce la o relatie de recurenta:daca

d: s → s’z val. asociata lui s, T(z,y) val. asociata lui s’,H algoritmul care calculeaza f(z) conform lui d,

atunci, aplicind PO, obtinemf(z) = optimy H(z, y, f(T(z,y)))

Documents

Curs 6 - Agendadlucanu/cursuri/ap/resurse/curs6.pdf · colorarea grafurilor submultimea de suma maxima Programare dinamica prezentare distanta dintre siruri. Dorel Lucanu Algoritmica