Structuri de Date și Algoritmi (seria 1AB)

Această pagină poate fi doar citită. Poți vedea sursa, dar nu poți modifica pagina. Consultă administratorul dacă ești de părere că ceva este în neregulă.
====== Laborator 10: Divide et impera și Greedy ======
\\ 
=====1 Obiectivele laboratorului=====
*Înțelegerea noțiunilor de bază legate de tehnicile D&I și greedy
*Însușirea abilităților de implementare a algoritmilor bazați pe greedy
*Înțelegerea implementării algoritmilor Greedy privind probleme de optimizare
*Înțelegera utilității practice ale paradigmei Divide et Impera:
   *Metode de sortare:Quicksort,Mergesort
   *Înmulțirea numerelor mari
   *Analiză sintactică:parsare top-down

\\ 

=====2 Algoritmul Greedy=====
====2.1 Prezentare generală====
Algoritmii de tip greedy vor să construiască într-un mod cât mai rapid soluția unei probleme.Ei se caracterizează prin luarea unor decizii rapide care duc la găsirea unei soluții potențiale a problemei.\\ 
Este in înțeles de ce un astfel de algoritm se numeste "lacom" (greedy), deoarece la fiecare pas, funcția alege **cel mai bun candidat la momentul respectiv**, **fără** să-i pese de **viitor** și **fără să revină** asupra alegerii. Daca un candidat este inclus în soluție, el rămâne în soluție, iar dacă un candidat este exclus din soluție, el nu va mai fi niciodată reconsiderat. \\ 

====2.2 Implementare ====
Descrierea formală a algoritmului este următoarea:\\ 
<file cpp>
function Greedy (C)
     //C = mulțimea candidaților
     //în S construim soluția
     S = ∅;
     while( !solutie(C) && C != ∅)
          x = un element din C care miniminează/maximizează select(x);
          C = C\(x);
     if( fezabil(S∪(x))
          S = S∪(x);
     return S;
</file>

====2.3 Probleme tip rezolvate cu acest algoritm====
===2.3.1 Problema spectacolelor===
Se dau mai multe spectacole, prin timpii de start și timpii de final.\\ 
Se cere o planificare astfel încât o persoană să poată vedea cât mai multe spectacole.\\ 
Rezolvarea constă în sortarea spectacolelor crescător după timpii de final, apoi la fiecare pas se alege primul spectacol care are timpul de start mai mare decât ultimul timp de final. Timpul inițial de final este inițializat la infinit (Spectacolul care se termină cel mai devreme va fi mereu selectat, având timp de start mai mare decât timpul inițial) \\ 

===2.3.2 Problema cuielor ===
Găsiți o mulțime de puncte de cardinal minim M astfel încât pentru orice interval [ai, bi] din cele N, să existe un punct x din M care să aparțină intervalului [ai, bi]. \\ 
Exemplu:
*Intrare: N=5 ,intervalele:[0,2],[1,7],[2,6],[5,14],[8,16];
*Ieșire M={2,14}
*Explicație: punctul 2 se afla în primele 3 intervale, iar punctul 14 în ultimele 2

Soluție:Se observă că dacă x este un punct din M care nu este capăt dreapta al nici unui interval, o translație a lui x la dreapta care îl duce în capătul dreapta cel mai apropiat nu va schimba intervalele care conțin punctul. Prin urmare,există o mulțime (M) de cardinal minim pentru care toate punctele x sunt capete dreapta.
\\ 
===2.3.3 Problema rucsacului===
Un rucsac ca poate transporta o greutate G, trebuie încărcat cu obiecte alese dintre 'n' obiecte, fiecare având o anumită greutate (g) și un anumit profit (importanță)(p) sau câștig. Se cere să se determine obiectele ce trebuie încărcate în rucsac astfel încât profitul (caștigul) să fie maxim.\\ 
Există posibilitatea ca obiectele să fie tăiate. În acest fel se poate obține o încărcare mai eficientă a rucsacului:
*Se determină pentru fiecare obiect eficiența de transport rezultată prin împărțirea profitului la greutatea obiectului;
*Se sortează obiectele în ordinea descrescătoare a eficienței de transport și se iau în calcul în această ordine;
*Inițial profitul este 0, iar greutatea rămasă de încărcat este egală cu G;
*Cât timp nu s-a ajuns la greutatea maximă (G) și nu au fost luate în considerare toate obiectele se va selecta obiectul cel mai eficient pentru care avem două variante:
   *Intră în întregime în rucsac și atunci se va scădea greutatea lui din cea rămasă de încărcat;
   *Nu intră în totalitate în rucsac și atunci se determină ce procent din obiectul respectiv va intra în rucsac; în acest caz se va cumula la câștigul total procentul de profit asociat părții din obiectul încărcat în rucsac, iar greutatea rămasă va fi zero.\\

===2.3.4 Problema comisului voiajor (TSP)===
Un comis-voiajor stă într-un oraş (X1) şi vrea să viziteze toate cele N oraşe dintr-o regiune (X1, X2, ..., XN), plecând dimineaţa de acasă (X1) şi întorcandu-se (tot în X1) la finalul zilei.

În mod ideal, el îşi doreşte să viziteze fiecare oraş exact o singură dată (excepţie făcând numai oraşul X1 unde se întoarce seara), iar drumul găsit să fie cât mai scurt.

Problema poate fi modelată cu grafuri (oraş = nod, drum între 2 oraşe = muchie) şi cerinţa devine găsirea unui **Ciclu/Circuit Hamiltonian minim** (un ciclu care conţine o singură dată fiecare nod, cu excepţia nodului de plecare care coincide doar cu nodul final, şi care este de cost minim).

<note warning>
Soluţia de **cost minim** pentru TSP **nu poate fi garantată** cu un algoritm de tip Greedy, dar un astfel de algoritm poate fi folosit pentru a găsi în timp util un drum.
</note>
Varianta **Greedy** (pură): -parcurgem în adâncime (DFS) graful din nodul de plecare (X1), continuând mereu pe cea mai ieftină muchie. La prima fundătură (primul nod din care nu mai avem vecini nevizitaţi), algoritmul se opreşte:
  * dacă algoritmul s-a blocat după ce a vizitat N noduri şi ultimul nod găsit (nodul curent) este vecin cu nodul de plecare (X1), atunci: mesaj de reuşită + soluţia găsită.
  * altfel: mesaj de nereuşită (+ eventual soluţia parţială).

Varianta **Greedy + revenire**: -la fel ca varianta Greedy (pură), dar permitem revenirea în cazul unui blocaj, respectând parcurgerea DFS (eliminăm nodul curent din soluţie, ne întoarcem la nodul găsit imediat înainte de nodul curent şi, din acel nod, alegem următoarea variantă).

<note warning>
Această variantă **nu** mai respectă principiul de bază al tehnicii Greedy, va avea nevoie de mai mult timp, dar va oferi un răspuns mai bun.
</note>

=====3 Paradigma Divide et impera =====
====3.1 Descriere====
Această metodă se poate aplica problemelor care permit descompunerea lor în subprograme independente (numele procedurii traducându-se prin //împarte și stăpânește.//)
Așadar obținem 3 faze principale:
* **Divide** - împarte problema în una/mai multe probleme similare de dimensiuni mai mici.
* **Stăpânește** - rezolvă subproblemele recursiv (dacă dimensiunea subproblemelor este mică,se rezolvă iterativ).
* **Combină** - combină soluțiile sub-problemelor pentru a obține soluția problemei inițiale.

====3.2 Implementare====
<file cpp>
void divide_et_impera(int P[],int n,int S[]{
     if(n <= n0 )
          Determină S prin metode elementare;
     else {
          Împarte P in:P1,P2,...,Pa
          divide_et_impera(P1,S1);
          ................................................
          divide_et_impera(Pa,Sa);
          Asamblează (S1,...,Sa,S);\
     }
}
</file>


====3.3 Complexitate====
//O(n) = D(n) + S(n) + C(n)// \\ 
Unde D(n),S(n) și C(n) reprezintă complexitățile celor 3 pași.
\\ 

====3.4 Exemple de algoritmi implementați cu D&I====
===3.4.1 Turnurile lui Hanoi===
Se consideră 3 tije A,B,C si n discuri de dimensiuni distincte (1,2,....n ordinea crestătoare a dimensiunilor) situate inițial toate pe tija A în ordinea 1,2..n (de la vârf către baza).\\ 
Singura operație case se poate efectua este de selecta un disc ce se află în vârful unei tije si plasarea lui în vârful altei tije,astfel încât să nu fie așezat deasupra unui disc de dimensiune mai mică decât a sa.\\ 
Să se găsească un algoritm prin ca\re se mută toate discurile pe tija B.\\ 
{{:laboratoare:hanoi1.jpg?300|#poza cu tijele#}}
{{ :laboratoare:hanoi2.jpg?300|}}

<note tip>
Pentru rezolvarea problemei folosim următoarea strategie:
*Mutăm primele n-1 discuri de pe tija A pe tija C folosindu-ne de tija B.
*Mutăm discul n pe tija B.
*Mutăm apoi cele n-1 discuri de pe tija C pe tija B folosindu-ne de tija A.

</note>





<note important>**Observație!** \\ Aplicabilitatea practică a acestei probleme se observă la back-up-ul pe mai multe medii de stocare/memorii.Scopul este de a muta datele dintr-un mediu în altul, ocupând stațiile libere fără a le partiționa.\\</note> 

===3.4.2 Căutare binară===
Se dă un vector sortat crescător ce conține valori reale distincte și o valoare x. \\
Să se găsească pe ce poziție apare x (introdus de la tastatură) în vectorul dat. \\ 
<note tip>Pentru rezolvarea problemei folosim următoarea strategie:
*Împărțim vectorul în doi sub-vectori de dimensiunea n/2. 
*Aplicăm algoritmul de căutare binară pe sub-vectorul care conține valoarea căutată
*Soluția sub-problemei devine soluția problemei inițiale, motiv pentru care nu mai este nevoie de etapa de combinare.

</note>  



<file cpp>
int binary_search(int v[],int start,int end,int x){
     if(start > end) return;
     mid = (start+end)/2;
     if( v[mid]==x )return mid;
     if( v[mid]>x )return binary_search(v,start,mid-1,x);
     if( v[mid]<x )return binary_search(v,mid+1,end,x);
}
</file>

===3.4.3 Determinarea rădăcinilor unei ecuații===
Se dă o funcție care are semne contrare în cele doua capete ale intervalului //[a,b],f(α) * f(β) < 0//.\\ 
Determinați o rădăcină a lui f din intervalul //[a,b]// cu o eroare //ε//. \\ 
Pentru rezolvarea problemei folosim următoarea strategie:împărțirea repetată a intervalului inițial //[α,β]// în jumătăți ale acestuia și selectarea intervalului jumătății în care se află soluția **(Metoda bisecției)**
\\ 
*Fie funcția //f:[α,β] → R//,continuă.Determinarea aproximației Δ',a rădăcinii exacte Δ, cu eroarea ε.
*Notăm cu m mijlocul intervalului ( m=(α+β)/2 )
*Verificăm dacă //f(m) * f(b) < 0//,ceea ce înseamnă că soluția se află în a doua jumătate a intervalului și îi atribuim lui α valoarea lui m.
*Altfel daca //f(m) * f(b) > 0//,soluția se află în prima jumătate a intervalului și ii atribuim lui β valoarea lui m.
*Acest procedeu se aplică în mod repetat până când lungimea intervalului scade cu 2*ε(β - α < 2*ε)\\ 

{{ :laboratoare:bisectie.jpg?400 |#poza funcție#}}

===3.4.4 Fractali===
Fractalii de tip Divide-et-Impera sunt construiți, după cum sugerează numele, prin //spargerea// componentei principale în mai multe părți și aplicarea //spargerii// asupra componentelor mai //mici// rezultate, până când se ajunge la cazul (componenta) de bază. La aceasta se ajunge efectuând un număr de apeluri ale funcției recursive egal cu numărul introdus.\\ 
Fractalii generați prin metode Divide-et-Impera au la bază un model simplu, pe baza căruia se adaugă (în cazul arborilor și al triunghiului lui Sierpinski) sau se înlocuiesc (în cazul fractalilor Koch) segmente, după o regulă bine definită, așa cum se poate observa:\\ 
{{ :laboratoare:fractali1.jpg?400 |# poza fractali arbore#}}

Se calculează coordonatele punctului de sfârșit al liniei ce trebuie reprezentată, în funcție de lungimea acesteia și de unghiul sub care va fi desenată.\\ 
Apoi este apelată de doua ori funcția de desenare, cu parametrii modificați: punctele de început ale următoarei linii vor avea coordonatele punctului de sfârșit al ultimelei linii desenate, lungimea va fi micșorată printr-un raport stabilit (ex: 4/7), numărul nivelului va fi cu o unitate mai mic, iar unghiul va fi modificat cu 45° (o dată în plus,a doua oară în minus) \\ 
Condiția de efectuare a instrucțiunilor din funcție este ca numărul de niveluri ale fractalului să fie mai mare decât 0. \\ 
\\
În cazul fractalilor de tip **Koch**, liniile nu se adaugă, ci se înlocuiesc. Pentru calcularea lungimii, poziției și unghiului fiecărui segment al liniei, funcția este apelată de n ori,segmentul fiind desenat atunci când nivelul devine 0. \\ 
La fractalul de tip Koch triunghiular, coordonatele care ne interesează se află la prima treime, a doua treime și jumatatea segmentului. La fiecare dintre acestea, unghiul de desenare se modifică cu 60°,-120°, respectiv 60°. \\ 

{{ :laboratoare:fractali2.jpg?400 |#poza fractali Koch triunghiular#}}

Ca și în cazul arborelui,fractalul **Sierpinski** este construit prin adăugarea de linii la imaginea generată până în acel moment, până când nivelul devine mai mic decât n.\\ 
Se pornește de la un triunghi în care au fost desenate liniile mijlocii și se desenează liniile mijlocii ale triunghiurilor mai mici marginale formate. \\ 
{{ :laboratoare:fractali3.jpg?400 |# poza fractali sierpinski#}}

**Aplicații practice!** \\ 
Teoria fractalilor a crescut interesul în domeniul compresiei de date și imagine, cu scopul reducerii cantității de date necesare pentru reprezentarea unei imegini. \\ 
Compresia este folosită în special pentru stocarea sau transmiterea imaginilor.\\ 
Compresia cu fractali se bazează pe faptul că în anumite imagini, părți ale imaginii seamănă cu părți ale aceeași imagini.\\ 
Tehnica copiază imaginea originală în 2 seturi: ranguri și domenii, apoi computer-ul face legătura fiecărui rang cu un domeniu și produce o trasformare de la domeniu la rang:\\ 
{{ :laboratoare:fractali4.png?400 |# poza compresia de data#}}

===3.4.5 Parser top-down===
Ca să putem introduce noțiunea de parser top-down este necesar să definim etapele compilării unui program C:\\ 
* **Analiza lexicală** - Descompune programul sursă în identificatori, cuvinte rezervate, constante ,operatori și îi introduce în tabela de simboluri sub formă codificată.
* **Analiza sintactică** - Se caută structuri sintactice, cum ar fi expresii, liste, proceduri, plasându-le într-un arbore de derivare
* **Analiza semantica** - Generează un grup de instrucțiuni simple cu format fix (cod intern)
* **Optimizarea codului**
* **Generarea codului** - Alocă zone de memorie pentru păstrarea datelor în timpul execuției și produce codul obiect (în limbaj de asamblare)
* **Gestiunea structurilor de date**
* **Tratarea erorilor**\\ 
\\ {{ :laboratoare:parser2.jpg?600 |# poza etapele procesului de compilare#}}

Vom trata problema analizei sintactice care are două obiective principale:
*Stabilește dacă un cuvânt dat aparține sau nu limbajului
*Determină arborele de derivare corespunzător cuvântului conform principiului Divide et Impera, problema fiind descompusă în alte doua subprobleme de același tip



=====4 Exerciții propuse=====
1. Simulați un proces de back-up a unor date fără a partiționa mediul de stocare.

2. Folosiţi un algoritm de tip Greedy pentru a găsi numărul minim de bancnote necesare pentru a da o anumită sumă de bani ca rest. Presupunem numai valori întregi pentru suma de bani şi următoarele bancnote: {1, 5, 10, 50, 100} (RON).

3*. Găsiţi un exemplu pentru care un algoritm de tip Greedy nu ar funcţiona pentru o problemă similară, dar care foloseşte următoarele bancnote: {1, 3, 5, 15, 30, 50, 150}. Încercaţi să explicaţi de ce, în acest caz, tehnica Greedy nu mai e optimă.

4*. Găsiţi un exemplu pentru care varianta Greedy (pură) de rezolvare a problemei TSP (comis-voiajor) găseşte o soluţie, dar aceasta nu este optimă.

5. Aproximaţi, printr-o abordare de tip Divide et Impera, cu o eroare (relativă) de maxim 1e-6, funcţia sqrt(n) (extragerea rădăcinii pătrate a unui număr). Nu aveţi voie să folosiţi nicio funcţie din "math.h". Încercaţi să extindeţi exerciţiul pentru extragerea radicalului de ordin 3.

6. Aproximaţi, printr-o abordare de tip Divide et Impera, cu o eroare (relativă) de maxim 1e-3, funcţia lg(n) (extragerea logaritmului în baza 10). Aveţi voie să vă folosiţi de funcţia pow(bază, exp) din "math.h".

7*. Problema 5 (extras logaritm) fără a vă folosi de funcţia pow, ci doar de funcţia construită la 4 (extragerea radicalului).

8**. Se dă un vector cu N numere întregi, apoi se fac un număr de C cereri de tipul "Calculează suma numerelor de la poziţia i până la poziţia j". Reduceţi sub O(N * C) timpul necesar pentru a răspunde la toate cererile dacă N este prea mare pentru a reţine în memorie toate perechile de sume(de la orice i la orice j) şi, în acelaşi timp, C > N. (Variantă alternativă - minim în loc de sumă)


===== 5. Exerciţii de laborator (Linux) =====
Pentru acest laborator puteți descărca scheletul de cod de [[http://elf.cs.pub.ro/sda-ab/wiki/_media/laboratoare/lab10_di_si_greedy-skel.zip|aici]]. Descărcați arhiva și dezarhivați-o. 

=== Linux===
Puteti folosi utilitarul ''%%wget%%'' pentru descarcare si utilitarul ''%%unzip%%'' pentru dezarhivare.

  * ''%%wget http://elf.cs.pub.ro/sda-ab/wiki/_media/laboratoare/lab10_di_si_greedy-skel.zip%%''
  * ''%%unzip lab10_di_si_greedy-skel.zip%%''

Pentru compilare folositi comanda ''%%make%%''.
Structuri de Date și Algoritmi (seria 1AB)

Unelte utilizator

Unelte site

Unelte pagină
