?? ?

?
Greedy
Backtracking

Metode de rezolvare a problemelor

cutare n spaiul soluiilor

Spaiul soluiilor
Fie mulimile ,

, o relaie de ordine pe

spaiul soluiilor

funcie de validare

mulimea soluiilor rezultat

funcii de validare parial

se poate aduga un element cu .

Greedy metoda optimului

local

Metod rapid, de complexitate redus, pentru obinerea unei

soluii acceptabile (nu neaprat cea mai bun)
La fiecare pas se alege cea mai bun cale n contextul local,
ignornd contextul general
Uneori soluia poate fi cea mai puin dezirabil

Este folosit atunci cnd gsirea celei mai bune soluii este prea
costisitoare

Greedy metoda optimului

local

Greedy metoda optimului

local
ale problemelor rezolvate prin metoda Greedy
Caracteristici

Problema poate fi imaginat ca o mulime cu elemente;

O soluie posibil este o submulime ( care ndeplinete o

condiie dat ( este acceptabil);

Pot exista mai multe submulimi diferite acceptabile (solu ii

posibile), dintre care una este considerat soluie optim, pe

baza unui criteriu care trebuie maximizat (minimizat).

Greedy metoda optimului

local
Opera
ii (nu snt ntotdeauna evidente)

Alegerea unui element candidat din mulimea (

Verificarea acceptabilitii elementului ales: adugarea

elementului la soluia parial construit o menine acceptabil

sau o face inacceptabil?
este acceptabil?
Adugarea elementului ales la soluia parial, dac ea rmne

acceptabil.

Greedy metoda optimului

local
Algoritm general

Cum se alege un element candidat?

Cum se verific
acceptabilitatea elementului
candidat?

se primete mulimea cu elemente

se iniializeaz soluia ca mulime vid
repet de (maxim) ori

alege un element candidat din mulimea

Variant:
verific dac este soluie parial acceptabil prelucrare
iniial a mulimii
dac da, adaug la mulimea :
A (sortare)
se trimite mulimea ca soluie

Greedy metoda optimului

local

Exemple de probleme rezolvate prin algoritmi de tip Greedy:

Determinarea arborelui parial de cost minim (soluia este ntotdeauna optim)

Algoritmul lui Kruskal, algoritmul lui Prim

Problema rucsacului
ntreag
continu

Interclasarea optim a n vectori

Suma maxim dintr-o mulime de numere

Enun
uri complete
Plata unei sume (cu
bancnot
unitate)

Problema paznicului

Determinarea unui produs de transpoziii

Algoritmul Dijkstra

n manual

Problema rucsacului (continu)

// I: capacitate totala (q), nr. obiecte (n), capacitate ocupata (c),
//
[ cistig (v) ]
// E: solutia x

void Rucsac_c(float q, int n, float* c, float* x)

{ float qr;
int i,j;
qr=q;
for(i=0; i<n && qr>0; i++)
if(qr>=c[i])
{ x[i]=1;
qr-=c[i];
//qr-=c[i]*x[i]
}
else
{ x[i]=qr/c[i];
qr=0;
//qr-=c[i]*x[i]
for(j=i+1;j<n;j++)
x[j]=0;
}
}

Backtracking cutare
complet
lent, costisitoare, complexitate mare
Metod

Verificarea (aproape) tuturor elementelor spa iului solu iilor

,,

- condiii de continuare

se construiete element cu element

primete o valoare din numai dup toate elementele anterioare ()

se trece la elementul
altfel se alege alt valoare pentru
valoarea aleas pentru e consumat mulimea valorilor consumate
dac nu mai snt valori disponibile se revine la elementul anterior
nu garanteaz obinerea unei soluii rezultat

Backtracking - reprezentare
date
ie curent
Configura

Configuraie iniial

Configuraie soluie

Configuraie final

Rezolvare problem:

Configuraie iniial configuraie soluie configuraie soluie configuraie final

Backtracking - operaii
i avanseaz
Atribuie

ncercare euat

Revenire

Revenire dup construirea unei soluii

Backtracking - forma general

ializare
ini

//construire

configuraie iniial

ct timp
//ct timp configuraia nu e final
dac
//configuraie de tip soluie?
reine soluia

//revenire dup construirea unei soluii

altfel
dac
//mai snt valori neconsumate
alege o valoare
dac

altfel

satisfac condiiile de continuare

//atribuie i avanseaz
//revenire

Backtracking variant

Particularit
i ale unor
probleme
//primul element
minus
raia, de multe ori 0=1-1
ct timp

//variabila
de impas
- progresii
aritmetice
cu valoarea iniial , raia i valoarea final
ct timp i
uneori , //alegerea unei noi valori pentru

//urmtorul termen n progresie

posibil(,vb)
//snt ndeplinite condiiile de continuare
dac toate snt identice
mulrevenire
imea
//impascu=>

altfel
dac
Avantaje
dac
condimemorate
ii_finale
(x)mulimile
//configura
ie soluie?
nu trebuie
explicit
i
reine_solu
ia
alegerea
unui element
neconsumat este uoar
altfel
//avans

Backtracking - implementare
recursiv

Metoda este de natur recursiv, deci uor de implementat recursiv

Forma recursiv general

backtracking(i)
dac i==n+1
retine_solutia();
altfel
pentru fiecare element j din Si
x[i]=j;
daca posibil(i)
backtracking(i+1);

Backtracking

Exemple de probleme care se rezolv prin metoda backtracking:

Problema celor 8 (n) regine.
Problema cavalerilor mesei rotunde.
Plata unei sume (cu/fr bancnot unitate).
Generarea tuturor permutrilor.
Generarea tuturor aranjamentelor.
Generarea tuturorEnun
uri complete n manual
combinrilor.
Problema colorrii hrilor.

Problema celor 8 regine

- coloana pe care se afl regina de pe linia i

,,

Condiie de continuare
Regina plasat,

nu e pe aceeai linie cu una plasat anterior

implicit, nu e nevoie de verificare
nu e pe aceeai coloan cu una plasat anterior
pentru
nu e pe aceeai diagonal cu una plasat anterior
pentru

Condiie final
nu e necesar

Problema celor 8 regine

// Retine o configuratie (afisare)
// I: nr. solutie (nr), nr dame (n), vector solutie
// E: void retine_solutia(int nr, int n, int* x)
{ int i,j;
printf("\n Solutia numarul %d\n",nr);
for(i=1; i<=n; i++)
{ for(j=1; j<=n; j++)
printf("%c",j==x[i]?'R':'.');
printf("\n");
}
if(r=='n')
{ printf("\n\nUrmatoarea (n) sau Ultima (l)?");
r=_getch();
}
}

Problema celor 8 regine

// Conditia de continuare
// I: solutia partiala (x), numarul de elemente (i)
// E: 1 daca e acceptabila, 0 daca nu e acceptabila
int posibil(int *x, int i)
{ int j, p;
p=1;
for( j=1; j<i; j++)
if( x[i]==x[j] || abs(i-j)==abs(x[i]-x[j]) )
p=0;
return p;
}

Problema celor 8 regine

// I: nr regine/dimensiune tabla (n) // E: nr solutii
int regine(int n)
{ int nr, *x, i, am;
x=new int[n+1];
//vectorul solutie
nr=0;
//numar solutii
i=1;
x[1]=0;
//prima valoare minus ratia
while(i>0)
//cit timp nu am ajuns la conf. finala
{ am=0;
while( x[i]<n && !am) //alege urm. val. acceptabila pentru x[i]
{ x[i]++;
//urmatoarea valoare pentru x[i]
am=posibil(x,i);
//este acceptabila?
}
if(!am) i--;
//impas, revenire
else
if( i==n )
//configuratie solutie
retine_solutia(++nr,n,x);
else
x[++i]=0;
//prima valoare minus ratia
}
delete x;
return nr;
}

Problema celor 8 regine

// I: numar dame (n), element curent (i), vector solutie (x), numar
solutii (nr)
// E: numar solutii
int regine_r(int n, int i, int* x, int nr)
{ int j;
if( i==n+1)
retine_solutia(++nr,n,x);
else
for(j=1; j<=n; j++ )
{ x[i]=j;
if( posibil(x,i) )
nr=regine_r(n,i+1,x,nr);
}
return nr;
}

Spor la nvat!