Divide
et impera este o tehnica de elaborare a
algoritmilor care consta in:

    Descompunerea cazului ce trebuie
rezolvat intr-un numar de subcazuri mai mici ale aceleiasi probleme.
    Rezolvarea succesiva si independenta
a fiecaruia din aceste subcazuri.
    Recompunerea subsolutiilor astfel
obtinute pentru a gasi solutia cazului initial.

Sa presupunem ca avem un algoritm A cu timp patratic. Fie c o
constanta, astfel incat timpul pentru a rezolva un caz de marime n este
t_A(n)  cn².
Sa presupunem ca este posibil sa rezolvam un astfel de caz prin descompunerea
in trei subcazuri, fiecare de marime n/2.
Fie d o constanta, astfel incat timpul necesar pentru descompunere si
recompunere este t(n)  dn.
Folosind vechiul algoritm si ideea de descompunere-recompunere a subcazurilor,
obtinem un nou algoritm B, pentru care:

t_B(n) = 3t_A(n/2)+t(n)  3c((n+1)/2)²+dn = 3/4cn²+(3/2+d)n+3/4c

Termenul 3/4cn² domina pe ceilalti cand n
este suficient de mare, ceea ce inseamna ca algoritmul B este in esenta cu 25% mai rapid decat algoritmul A. Nu am reusit insa sa schimbam ordinul
timpului, care ramane patratic.

Putem sa continuam in mod recursiv acest
procedeu, impartind subcazurile in subsubcazuri etc. Pentru subcazurile care nu
sunt mai mari decat un anumit prag n₀, vom folosi
tot algoritmul A. Obtinem astfel
algoritmul C, cu timpul

Conform rezultatelor din Sectiunea 5.3.5, t_C(n)
este in ordinul lui n^lg 3. Deoarece lg 3 @ 1,59,
inseamna ca de aceasta data am reusit sa imbunatatim ordinul timpului.

Iata o descriere generala a metodei divide
et impera:

function divimp(x)
{returneaza o solutie pentru cazul x}
if
x este suficient de mic then return adhoc(x)
{descompune x in subcazurile x₁, x₂, , x_k}
for i 1 to k do
y_i divimp(x_i)
{recompune y₁, y₂, , y_k in scopul obtinerii solutiei y
pentru x}
return
y

unde adhoc
este subalgoritmul de baza folosit pentru rezolvarea micilor subcazuri ale
problemei in cauza (in exemplul nostru, acest subalgoritm este A).

Un algoritm divide et impera trebuie sa
evite descompunerea recursiva a subcazurilor suficient de mici, deoarece,
pentru acestea, este mai eficienta aplicarea directa a subalgoritmului de baza.
Ce inseamna insa suficient de mic?

In exemplul precedent, cu toate ca valoarea
lui n₀ nu influenteaza ordinul timpului,
este influentata insa constanta multiplicativa a lui n^lg 3, ceea ce poate avea un rol considerabil in eficienta algoritmului.
Pentru un algoritm divide et impera oarecare, chiar daca ordinul timpului nu
poate fi imbunatatit, se doreste optimizarea acestui prag in sensul obtinerii
unui algoritm cat mai eficient. Nu exista o metoda teoretica generala pentru
aceasta, pragul optim depinzand nu numai de algoritmul in cauza, dar si de
particularitatea implementarii. Considerand o implementare data, pragul optim
poate fi determinat empiric, prin masurarea timpului de executie pentru
diferite valori ale lui n₀ si cazuri de
marimi diferite.

In general, se recomanda o metoda hibrida
care consta in: i) determinarea
teoretica a formei ecuatiilor recurente; ii)
gasirea empirica a valorilor constantelor folosite de aceste ecuatii, in
functie de implementare.

Revenind la exemplul nostru, pragul optim
poate fi gasit rezolvand ecuatia

t_A(n) = 3t_A(n/2) + t(n)

Empiric, gasim n₀ @ 67, adica valoarea pentru care nu mai are importanta daca
aplicam algoritmul A in mod direct,
sau daca continuam descompunerea. Cu alte cuvinte, atata timp cat subcazurile
sunt mai mari decat n₀, este bine sa
continuam descompunerea. Daca continuam insa descompunerea pentru subcazurile
mai mici decat n₀, eficienta
algoritmului scade.

Observam ca metoda divide et impera este
prin definitie recursiva. Uneori este posibil sa eliminam recursivitatea printr-un
ciclu iterativ. Implementata pe o masina conventionala, versiunea iterativa poate fi ceva mai rapida (in limitele
unei constante multiplicative). Un alt avantaj al versiunii iterative ar fi
faptul ca economiseste spatiul de memorie. Versiunea recursiva foloseste o
stiva necesara memorarii apelurilor recursive. Pentru un caz de marime n, numarul apelurilor recursive este de
multe ori in W(log n),
uneori chiar in W(n).

Pagini: 1 2 3 4 5 6 7 8 9 10

- iată o soluţie simplă care iniţializează labirintul în mod static, ca o matrice de caractere

#include
#include
#include
#define XMAX 6
#define YMAX 6

char a[XMAX+1][YMAX+1]={
“*******”,
“* * *”,
“* * * *”,
“* * ****”,
“** * *”,
“* * “,
“********”
};
int x0=1,y0=2;

void print(void){
int i,j;
for(i=0;i<=XMAX;i++){
for(j=0;j<=YMAX;j++)putchar(a[i][j]);
putchar('\n');
}
getchar();clrscr();
}

void escape(int x,int y){
if(x==XMAX || y==YMAX){ puts("Succes!");exit(1);}
a[x][y]='*';print();
if(a[x][y+1]==' '){puts("la dreapta");escape(x,y+1);}
if(a[x+1][y]==' '){puts("in jos ");escape(x+1,y);}
if(a[x][y-1]==' '){puts("la stinga ");escape(x,y-1);}
if(a[x-1][y]==' '){puts("in sus ");escape(x-1,y);}
return;
}

void main(void){
escape(x0,y0);
puts("Traped!");
}

- poate avea mai multe soluţii, acestea fiind puse sub formă de vector ca de exemplu S(x1,x2,x3,…xn), unde x1ЄA1, x2ЄA2,…, xnЄAn

- mulţimile A1, A2, A3, …, An sunt mulţimi finite, având elementele aflate într-o ordine bine stabilită, ele putând să fie chiar identice.

În acest caz, vectorul care conţine soluţii se numeşte stivă.
Se alege primul element x1 din A1. Se repetă într-o structură repetitivă până când nu mai există elemente netestate din mulţimea A1;

- se presupune că am ajuns la elementul xk din mulţimea Ak şi se doreşte găsirea unui element xk+1 din mulţimea Ak+1. Acesta trebuie să îndeplinească condiţiile de existenţă a unui astfel de element, impuse de problemă, iar dacă:

- îndeplineşte aceste condiţii atunci trebuie să îndeplinească alte condiţii impuse de problemă, prin care se determină dacă el ar putea face parte din soluţie. Dacă: (1)da, atunci se testează dacă şirul de elemente este o soluţie a problemei; dacă: (2) da, atunci se tipăreşte vectorul care conţine aceste soluţii; (2) nu, atunci se trece pe următorul nivel din şir (k:=k+1); (1) nu, nu îndeplineşte condiţiile de a face parte din soluţie, atunci se trece la următorul element netestat din mulţimea Ak; nu mai poate exista un element pe nivelul k, atunci se trece la nivelul anterior şi se încearcă aici găsirea unui element; repetiţia se termină când am ajuns pe nivelul 0.

Un exemplu de problemă ce foloseşte tehnica backtraking este Problema Labirintului