1 / 13

Algoritmi și tehnici de programare

?. ?. ?. ?. Divide et impera. Algoritmi și tehnici de programare. Divide et impera. Determinarea elementului maxim dintr-o mulțime Metoda bisecției. Metodă de rezolvare a unor probleme Caracteristici probleme pot fi descompuse în probleme cu complexitate mai mică

linnea
Download Presentation

Algoritmi și tehnici de programare

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. ? ? ? ? Divide et impera Algoritmi și tehnici de programare

  2. Divide et impera Determinarea elementului maxim dintr-o mulțime Metoda bisecției • Metodă de rezolvare a unor probleme • Caracteristici probleme • pot fi descompuse în probleme cu complexitate mai mică • de același tip / cu soluție cunoscută • descompunerea este finită – problemă primitivă / condiție de terminare • cîte probleme? • cum se face împărțirea? • rezolvarea noilor probleme este mai ușoară • soluțiile combinate  soluția problemei inițiale • Descompunere propriu-zisă / reducere

  3. Divide et impera • Algoritm recursiv • Implementarea este de obicei recursivă • Forma generală • S= • determină o modalitate de descompunere a problemei P => P1, P2, … Pn • pentru fiecare i=1:n • aplică recursiv algoritmul, pentru rezolvarea problemei Pi => Si • S=S Si

  4. Divide et impera • Exemple • Probleme de parcurgere • Problema turnurilor din Hanoi • Problema tăieturilor • Probleme de căutare • secvențială / binară • Probleme de sortare • prin interclasare • prin inserare • rapidă (quick sort) • metoda micșorării incrementului (Shell sort)

  5. Divide et impera • Probleme de parcurgere • o mulțime a, cu n elemente => P(a, 0, n) • P(a, i, n) se descompune în • prelucrare a[i] • P(a, i+1, n) voidparcurge(float*v, int i, int n) { if( i!=n ) { printf("%7.2f ",v[i]); parc(v,i+1,n); } }

  6. Divide et impera • Problema turnurilor din Hanoi • H(n, S, D, I) • H(n-1, S, I, D) • mută un disc de pe S pe D • H(n-1, I, D, S) voidhanoi(intn, char s, char d, chari) { if(n>0) { hanoi(n-1,s,i,d); printf("\nMuta un disc de pe %cpe%c",s,d); hanoi(n-1,i,d,s); } } hanoi( 5, ‘a’, ‘b’, ‘c’); Sursă Destinație Intermediar

  7. Divide et impera voidtaietura(int**c,intx, inty, inta, intb, int*xm, int*ym, int *am, int *bm) { inti,gasit; for( i=gasit=0; (i<n)&&!gasit; ) if((c[0][i]>x)&&(c[0][i]<x+a) && (c[1][i]>y)&&(c[1][i]<y+b)) gasit=1; else i++; if(gasit) { taietura(c, x,c[1][i], a,b-c[1][i]+y, xm,ym,am,bm); taietura(c, x,y, a,c[1][i]-y, xm,ym,am,bm); taietura(c, x,y, c[0][i]-x,b, xm,ym,am,bm); taietura(c, c[0][i],y, a-c[0][i]+x,b, xm,ym,am,bm); } else if(a*b>(*am)*(*bm)) { *am=a; *bm=b; *xm=x; *ym=y; } } • Problema tăieturilor x, y, a, b , c[2,n] 1: x, c[1,i] a, y+b-c[1,i] y+b 2: x, y a, c[1,i]-y 1 3 4 3: x, y c[0,i]-x, b 4: c[0,i], y x+a-c[0,i], b c[1,i] 2 xmax, ymax amax=0, bmax=0 y x c[0,i] x+a a b

  8. Divide et impera • Probleme de căutare • Secvențială  problemă de parcurgere (mulțimi sortate sau nesortate) • Binară (mulțimi sortate) • Nu există riscul să se obțină poziția -1 chiar dacă elementul căutat se află în mulțime, deoarece în momentul găsirii lui, nu se mai face nici un apel recursiv și nu se mai modifică valoarea lui poz • Mulțime nesortată • C(x, a, i, n, poz) • dacă i==n • poz=-1 • altfel • dacă x==a[i] • poz=i • altfel • C(x, a, i+1, n, poz) • Mulțime sortată • C(x, a, i, n, poz) • dacă i==n || a[i]>x • poz=-1 • altfel • dacă x==a[i] • poz=i • altfel • C(x, a, i+1, n, poz) • C(x, a, p, u, poz) • dacă p>u • poz=-1 • altfel • m=(p+u)/2 • dacă x==a[m] • poz=m • altfel • daca x<a[m] • C(x, a, p, m-1, poz) • altfel • C(x, a, m+1, u, poz)

  9. Divide et impera • Sortare prin interclasare • S(a, n) => S(a, 0, n-1) • dacă p<u • m=(p+u)/2 • S(a, p, m) • S(a, m+1, u) • interclasează a[p:m] cu a[m+1:u] S(0, 14) 15 7 13 5 11 3 1 8 14 6 12 4 10 2 9 S(0, 7) S(8, 14) 15 7 13 5 11 3 1 814 6 12 4 10 2 9 … 1 3 5 7 8 11 13 15 2 4 6 9 10 12 14 1 2 3 4 5 6 7 89 10 11 12 13 14 15

  10. Divide et impera • Sortare rapidă • Q(x, p,u) • dacă p<u • poziționare(x, p, u, k) • Q(x, p, k-1) • Q(x, k+1, u) Q(0, n-1) x[0] x[1] x[2] … x[k-2] x[k-1] x[k] x[k+1] x[k+2] … x[n-1] Q(0, k-1) Q(k+1, n-1) x[0] x[1] x[2] … x[k-2] x[k-1]x[k]x[k+1] x[k+2] … x[n-1] 10 9 19 15 3 17 4 1 -1 0 0 1

  11. Divide et impera • Sortare prin micșorarea incrementului (Shell sort) • generalizare a sortării prin inserție • vector k-sortat • secvență de pași : valori descrescătoare, ultima este 1 • Algoritm • pentru fiecare pas din secvență • pentru fiecare i=pas..n-1 • j=i-pas • cît timp j>0 și v[j]<v[j+pas] • v[j] <->v[j+pas] • j-=pas

  12. Divide et impera • Sortare prin micșorarea incrementului (Shell sort) indici0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 n=15 Initial:38 13 85 98 5 70 45 44 68 71 40 44 9 10 3 Dupa pasul 7: 313714059 10 386885984470 45 44 Dupa pasul 3: 35 9 1013 44 4038 44 7045 68 8598 71 Dupa pasul 1: 3 5 9 10 13 38 40 44 44 45 68 70 71 85 98 void sort_shell(double v[], int l) { int i,j,inc; double a; for(inc=l/2; inc>0; inc=inc/2) for(i=inc; i<l; i++) for(j=i-inc; (j>=0)&&(v[j]>v[j+inc]); j=j-inc) { a=v[j]; v[j]=v[j+inc]; v[j+inc]=a; } }

  13. Spor la învăţat!

More Related