UNIVERSITATEA BABE-BOLYAI

Facultatea de Matematic i Informatic

FUNDAMENTELE
PROGRAMRII
Metode de rezolvare a problemelor
Backtracking
Divide et impera

Laura Dioan

Coninut curs

Introducere n procesul de dezvoltare software

Programare procedural
Programare modular
Tipuri definite de utilizator
Principii de dezvoltare a aplicaiilor soft
Testarea i inspectarea programelor
Recursivitate
Complexitatea algoritmilor
Metode de rezolvare a problemelor

Backtracking
Divide et impera
Programare dinamic
Greedy

Algoritmi de cutare
Algoritmi de sortare
Recapitulare

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

Sumar

Rezolvarea problemelor

Tipologie
Tehnici

Divide et impera

Backtracking

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

Probleme

Tipologie

n funcie de structur

Care pot fi descompuse n sub-probleme

Cutarea unui element ntr-un vector
Care nu pot fi descompuse
Amplasarea reginelor pe o tabl de ah

n funcie de numrul de soluii

Cu

Cu

Decembrie, 2013

o singur soluie
Sortarea unui vector
mai multe soluii
Generarea permutrilor
Fundamentele programrii - tehnici de rezolvare a problemelor

Probleme

Tipologie

n funcie de posibilitile de rezolvare

Decembrie, 2013

Rezolvabile n mod determinist

Calculul sinusului unui unghi sau a rdcinii
ptrate dintr-un numr
Rezolvabile n mod stocastic (euristic)
Probleme din lumea real proiectarea unui ABS
Presupun cutarea unei soluii

Fundamentele programrii - tehnici de rezolvare a problemelor

Probleme

Tipologie

n funcie de complexitatea temporal a

rezolvrii

Decembrie, 2013

Probleme din clasa P rezolvabile n timp polinomial

(n2, n3, ...)
sortri
Probleme din clasa NP rezolvabile n timp non
polinomial (2n, n!,, ..)
Cel mai scurt drum ntr-un graf de orae

Fundamentele programrii - tehnici de rezolvare a problemelor

Probleme

Tipologie

n funcie de scop

Probleme de cutare/optimizare
intrri

Planificare, proiectarea sateliilor

Probleme de modelare

Predicii, clasificri

intrri

model

ieiri

Probleme de simulare

Teoria jocurilor economice

Decembrie, 2013

model

ieiri

intrri

Fundamentele programrii - tehnici de rezolvare a problemelor

model

ieiri

Rezolvarea problemelor

Const n identificarea unei soluii

n informatic proces de cutare

n inginerie i matematic proces de optimizare

Cum?

Decembrie, 2013

Reprezentarea soluiilor (pariale) puncte n spaiul

de cutare
Proiectarea unor operatori de cutare transform o
posibil soluie n alt soluie

Fundamentele programrii - tehnici de rezolvare a problemelor

Pai n rezolvarea problemelor

Definirea problemei

Analiza problemei

Alegerea unei tehnici de rezolvare

cutare
reprezentarea cunotinelor
abstractizare

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

Pai n rezolvarea problemelor prin cutare

Alegerea unei tehnici de rezolvare

Rezolvarea prin utilizarea regulilor (n combinaie cu o

strategie de control) de deplasare n spaiul problemei
pn la gsirea unui drum ntre starea iniial i cea
final

Rezolvare prin cutare

Decembrie, 2013

Examinarea sistematic a strilor posibile n vederea

identificrii
unui drum de la o stare iniial la o stare final
unei stri optime
Spaiul strilor = toate strile posibile + operatorii care
definesc legturile ntre stri

Fundamentele programrii - tehnici de rezolvare a problemelor

10

Pai n rezolvarea problemelor prin cutare

Alegerea unei tehnici de rezolvare

Rezolvare prin cutare

Strategii de cutare multiple cum alegem o

strategie?

Decembrie, 2013

Complexitatea computaional (temporal i spaial)

Completitudine algoritmul se sfrete ntotdeauna i gsete o
soluie (dac ea exist)
Optimalitate algoritmul gsete soluia optim (costul optim al
drumului de la starea iniial la starea final)

Fundamentele programrii - tehnici de rezolvare a problemelor

11

Pai n rezolvarea problemelor prin cutare

Alegerea unei tehnici de rezolvare

Rezolvare prin cutare

Strategii de cutare multiple cum alegem
o strategie?

Decembrie, 2013

Complexitatea computaional (temporal i spaial)

Performana strategiei depinde de:
Timpul necesar rulrii
Factori interni
Spaiul (memoria) necesar rulrii
Mrimea intrrilor algoritmului
Factori externi
Viteza calculatorului
Calitatea compilatorului
Se msoar cu ajutorul complexitii Eficien computaional
Spaial memoria necesar identificrii soluiei
S(n) cantitatea de memorie utilizat de cel mai bun algoritm A
care rezolvp o problem de decizie f cu n date de intrare
Temporal timpul necesar identificrii soluiei
T(n) timpul de rulare (numrul de pai) al celui mai bun
algoritm A care rezolv o problem de decizie f cu n date de
intrare

Fundamentele programrii - tehnici de rezolvare a problemelor

12

Pai n rezolvarea problemelor prin cutare

Alegerea unei tehnici de rezolvare

Rezolvarea problemelor prin cutare poate

consta n:

Construirea progresiv a soluiei

Identificarea soluiei poteniale optime

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

13

Pai n rezolvarea problemelor prin cutare

Alegerea unei tehnici de rezolvare

Rezolvarea problemelor prin metode

clasice

Metode exacte

Metoda generrii i testrii

backtracking
Metoda divizrii -> Divide et Impera
Metoda programrii dinamice

Metode euristice

Decembrie, 2013

Metoda greedy

Fundamentele programrii - tehnici de rezolvare a problemelor

14

Gnereaz i testeaz

Ideea de baz

Mecanism

Generarea unei posibile soluii i verificarea

corectitudinii ei
Trial and error
Cutare exhaustiv

Generare: determianrea tuturor soluiilor posibile

Testare: cutarea acelor soluii care sunt corecte
(respect anumite condiii)

Cnd se poate folosi

Probleme care pot avea mai multe soluii

Probleme cu constrngeri (ale cror soluii trebuie s
respecte anumite condiii)

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

15

Genereaz i testeaz

Algoritm
#D = D(D1) = D(D1(D2))...
def generate_test(D):
while (True):
sol = generate_solution()
if (test(sol) == True):
return sol

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

16

Genereaz i testeaz

Exemple

Generarea permutrilor cu n=3 elemente

def permut3():
for i in range(1,4):
for j in range(1,4):
for k in range(1, 4):
#generate
possibleSolution = [i,j,k]
#test
if ((i != j) and (j != k) and (k != i)):
print(possibleSolution)

[1,
[1,
[2,
[2,
[3,
[3,

2,
3,
1,
3,
1,
2,

3]
2]
3]
1]
2]
1]

Analiza complexitii

Numrul de soluii posibile: 33, adic nn

start

1
1
1

2
3

Decembrie, 2013

3
3

1
3

2
3

3
3

1
3

2
3

Fundamentele programrii - tehnici de rezolvare a problemelor

3
3

17

Genereaz i testeaz

Algoritm

Adugarea de condiii la generarea unei soluii

nu se mai exploreaz toate soluiile posibile

se construiesc soluii (parial) corecte
care respect anumite condiii
#D = D(D1) = D(D1(D2))...
def generate_test(D):
while (True):
sol = generate_solution_cond()
if (test(sol) == True):
return sol

Backtracking

Spaiul de cutare al unei soluii s este S (domeniul de definiie)

O soluie este format din mai multe elemente (s[0], s[1], s[2],...)
Funcia init genereaz o valoare nul pentru domeniul de definiie al
soluiei
Funcia getNext returneaz succesorul (din domeniul de definiie) al
unui element al soluiei
Funcia isConsistent verific dac o soluie (parial) este corect
Funcia isSolution verific dac o soluie (parial) este soluie final
(complet) a problemei

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

18

Genereaz i testeaz

Exemple

Generarea permutrilor cu n=3 elemente

Backtracking - variant iterativ

def init():
return 0

def getNext(sol, pos):

return sol[pos] + 1
def isConsistent(sol):
isCons = True
i = 0
while ((i<len(sol)-1) and (isCons==True)):
if (sol[i] == sol[len(sol) - 1]):
isCons = False
else:
i = i + 1
return isCons
def isSolution(solution, n):
return len(solution) == n

def permut_back(n):
k = 0
solution = []
initValue = init()
solution.append(initValue)
while (k>= 0):
isSelected = False
while ((isSelected==False) and
(solution[k]<getLast(n))):
solution[k] = getNext(solution, k)
isSelected = isConsistent(solution)
if (isSelected == True):
if (isSolution(solution,n) == True):
print(solution)
else:
k = k + 1
solution.append(init())
else:
del(solution[k])
k = k - 1
permut_back(3)

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

19

Genereaz i testeaz

Exemple

Generarea permutrilor cu n=3 elemente

Backtracking - variant recursiv

def init():
return 0

def getNext(sol, pos):

return sol[pos] + 1
def isConsistent(sol):
isCons = True
i = 0
while ((i<len(sol)-1) and (isCons==True)):
if (sol[i] == sol[len(sol) - 1]):
isCons = False
else:
i = i + 1
return isCons

def permut_back_rec(n, solution):

initValue = init()
solution.append(initValue)
elem = getNext(solution, len(solution) - 1)
while (elem <= n):
solution[len(solution) - 1] = elem
if (isConsistent(solution) == True):
if (isSolution(solution, n) == True):
print(solution)
else:
permut_back_rec(n, solution[:])
elem = getNext(solution, len(solution) - 1)

sol = []
permut_back_rec(3, sol)

def isSolution(solution, n):

return len(solution) == n

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

20

Genereaz i testeaz

Exemple

Backtracking

Analiza complexitii
start

1
1
1

2
3

Decembrie, 2013

3
3

1
3

2
3

3
3

1
3

2
3

Fundamentele programrii - tehnici de rezolvare a problemelor

3
3

21

Genereaz i testeaz

Exemple

Generarea turnurilor de m cuburi care nu se

rstoarn avnd la dispoziie n cuburi
towers(n, m):
Backtracking - variantdefiterativ

cubes = [10,2, 5, 6, 7]
def init():
return 0
def getNext(sol, pos):
return sol[pos] + 1
def getLast(n):
return n
def isConsistent(sol):
isCons = True;
i = 0
while ((i<len(sol)-1) and (isCons==True)):
if (sol[i] == sol[len(sol) - 1]):
isCons = False
else:
i = i + 1
if (len(sol) > 1):
if (cubes[sol[len(sol) - 1] - 1] >
cubes[sol[len(sol) - 2] - 1]):
return False
return isCons
def isSolution(solution, n):
return len(solution) == n
def print_sol(solution):
tower = []
for s in solution:
tower.append(cubes[s - 1])
print(tower)
Decembrie, 2013

k = 0
solution = []
initValue = init()
solution.append(initValue)
while (k>= 0):
isSelected = False
while ((isSelected == False) and
(solution[k] < getLast(n))):
solution[k] = getNext(solution, k)
isSelected = isConsistent(solution)
if (isSelected == True):
if (isSolution(solution,m) == True):
print_sol(solution)
else:
k = k + 1
solution.append(init())
else:
del(solution[k])
k = k - 1

towers(len(cubes), 4)

Fundamentele programrii - tehnici de rezolvare a problemelor

22

Divide et impera

Ideea de baz

Mecanism

Descompunerea problemei n sub-probleme independente i

similare problemei iniiale, dar de dimensiuni mai mici,
rezolvarea sub-problemelor i stabilirea soluiei finale prin
combinarea sub-soluiilor

Divide: mprirea problemei n sub-probleme

Conquer: rezolvarea sub-problemelor
Combine: combinarea sub-soluiilor pentru obinerea
soluiei finale

Cnd se poate folosi

Problema P avnd datele de intrare D poate fi rezolvat prin

rezolvarea aceleiai probleme P, dar cu datele de intrare d,
unde d < D

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

23

Divide et impera

Algoritm
#D = d1 U d2 U d3...U dn
def div_imp(D):
if (size(D) < lim):
return rez
rez1 = div_imp(d1)
rez2 = div_imp(d2)
...
rezn = div_imp(dn)
return combine(rez1, rez2, ..., rezn)

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

24

Divide et impera

Exemple

S se gseasc elementul maxim dintr-o list

Size(problema) = n
Versiunea 1
Size(sub-problema1) = n -1
Size(sub-problema2) = n-2 def
...
adic:
D = l = [l1,l2,..,ln],
d1 = [l2,..,ln],
d2 = [l3,..,ln],
...
1,
n 1

T ( n)
T (n 1) 1, altfel
T (n) T (n 1) 1
T (n 1) T (n 2) 1
...
T (2) T (1) 1

T (n) 1 1 .. 1 n O(n)

Decembrie, 2013

findMax(l):
'''
descr: finds the maximul elem of a list
data: a list
res: the maximal elem of list
'''
if (len(l) == 1):
return l[0]
max = findMax(l[1:])
if (max > l[0]):
return max
else:
return l[0]

def test_findMax():
assert findMax([2,5,3,6,1]) == 6
assert findMax([12,5,3,2,1]) == 12
assert findMax([2,5,3,6,11]) == 11
test_findMax()

Fundamentele programrii - tehnici de rezolvare a problemelor

25

Divide et impera

Exemple

S se gseasc elementul maxim dintr-o list

Size(problema) = n
Versiunea 2
Size(sub-problema1) = n/2
Size(sub-problema2) = n/2
adic:
D = l = [l1,l2,..,ln],
d1 = [l1,..,ln/2],
d2 = [ln/2+1,..,ln]
1,
n 1

T ( n)
2 * T (n / 2) 1, altfel
n 2 k k log 2 n
T (2 k ) 2 * T (2 k -1 ) 1
2 * T (2 k -1 ) 2 2 * T (2 k -2 ) 2
2 2 * T (2 k -2 ) 23 * T (2 k -2 ) 2 2
...
2

k 1

* T ( 2) 2 * T ( 2 ) 2
k

k 1

T (n) 1 21 2 2 .. 2 k (2 k 1 1) /( 2 1)
T (n) 2 k * 2 1 2n 1 O(n)
Decembrie, 2013

def findMax_v2(l):
'''
descr: finds the maximul elem of a list
data: a list
res: the maximal elem of list
'''
if (len(l) == 1):
return l[0]
middle = len(l) // 2
max_left = findMax_v2(l[0:middle])
max_right = findMax_v2(l[middle:len(l)])
if (max_left < max_right):
return max_right
else:
return max_left
def test_findMax_v2():
assert findMax_v2([2,5,3,6,1]) == 6
assert findMax_v2([12,5,3,2,1]) == 12
assert findMax_v2([2,5,3,6,11]) == 11
test_findMax_v2()

Fundamentele programrii - tehnici de rezolvare a problemelor

26

Recapitulare

Divide et impera

Genereaz i testeaz

exhaustiv
backtracking

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

27

Cursul urmtor

Rezolvarea problemelor prin metode clasice

Metode exacte

Metoda generrii i testrii

Metoda divizrii -> Divide et Impera
Metoda programrii dinamice

Metode euristice

Metoda greedy

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

28

Materiale de citit i legturi utile

1.

Limbajul Python
http://docs.python.org/3/reference/index.html

2.

Biblioteca standard Python

http://docs.python.org/3/library/index.html

3.

Tutorial Python
http://docs.python.org/3/tutorial/index.html

4.

Frentiu, M., H.F. Pop, Fundamentals of Programming, Cluj University

Press, 2006, 220 pagini

5.

Kent Beck.Test Driven Development: By Example. AddisonWesley Longman, 2002

http://en.wikipedia.org/wiki/Test-driven_development

6.

Martin Fowler. Refactoring. Improving the Design of Existing

Code. Addison-Wesley, 1999
http://refactoring.com/catalog/index.html

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

29

Informaiile prezentate au fost colectate din

diferite surse de pe internet, precum i din
cursurile de Fundamentele Programrii inute n
anii anteriori de ctre:

Lect. Dr. Adriana Guran www.cs.ubbcluj.ro/~adriana

Lect. Dr. Istvan Czibula - www.cs.ubbcluj.ro/~istvanc

Lect. Dr. Andreea Vescan -www.cs.ubbcluj.ro/~avescan

Lect. Dr. Ioan Lazr -www.cs.ubbcluj.ro/~ilazar

Decembrie, 2013

Fundamentele programrii - tehnici de rezolvare a problemelor

30