Divide+et+impera

=** Divide et Impera ( Împarte şi stăpâneşte)- ** tehnica a recursivitatii =
 * Divide **– presupune împărţirea unei probleme în 2 sau mai multe subprobleme ( regula de impartire depinde de enunt/cerinta....de logica/spatiul cautarii pentru rezolvarea cerintei) ;
 * Rezolvă(Calcul efectiv conform cerintei) **- rezolvarea independentă a fiecărei subprobleme, fiecare subproblemă având, teoretic, o anumită soluţie;
 * Impera **(stăpâneşte)- combinarea soluţiilor(parţiale) obţinute în etapa anterioara pentru fiecare subproblema ;

//I. Exemple didactice ( care nu justifica neaparat utilizarea acestei metode): // //#include //
 * **//suma elementelor dintr-un vector//**

//using namespace std;// //ifstream f("div.in");// //ofstream g("div.out");// //int v[100],n;// //** void divide **(int stanga, int dreapta,int &mijloc)// //{ mijloc=(stanga+dreapta)/2; }// //** void impera **(int a, int b, int &sol)// //{ sol=a+b; }// //** void calcul **(int stanga, int dreapta, int v[], int &sol)// //{ int a,b,mijloc;// //if(stanga==dreapta)// //{ sol=v[stanga]; }// //else// //{ ** divide(stanga, dreapta, mijloc); **// //** calcul(stanga, mijloc,v,a); **// //** calcul(mijloc+1, dreapta,v,b); **// //** impera(a,b,sol); **// //}// //}// //int main// //{ int i,sol;// //f>>n;// //for(i=1;i<=n;++i) f>>v[i];// //** calcul(1,n,v,sol); **g<b)a=a-b; else b=b-a; sol=a;
 * void impera **(int a, int b, int &sol)

}


 * Daca dorim sa numaram cate elemente dintr-un sir indeplinesc**
 * o anumita proprietate, modificarea poate fi facuta in subprogramul**
 * calcul de exemplu:**

{ int a,b,mijloc; if(stanga==dreapta) { verific proprietatea...par in cazul de fata } // adun 1 sau 0 daca elementul respectiv indeplineste sau nu proprietatea respectiva || =// II. Exemple in care se recomanda utilizarea acestei metode //=
 * Ex.didactic :pare/impare :**
 * void calcul **(int stanga, int dreapta, int v[], int &sol)
 * if(v[stanga]%2==0) sol=1;**
 * else sol=0;**
 * || (Ex. AEL numarul de elemente impare dintr-un sir) ||
 * ==**Cautare Binara**==
 * Se considera un vector cu n elemente.**
 * Elementele vectorului suntsortate crescator. **
 * Sa se verifice daca o anumita valoare (val) se gaseste in vector.**
 * In caz afirmativ, sa se afiseze pozitia pe care se gaseste,**
 * altfel sa se afiseze 0**

using namespace std; ifstream f("div.in"); ofstream g("div.out"); int v[100],n; { mijloc=(stanga+dreapta)/2; }
 * void divide**(int stanga, int dreapta,int &mijloc)


 * void CautareBinara(int stanga, int dreapta, int v[],int val, int &sol) **
 * { int mijloc; **
 * if(stanga>dreapta) sol=0; **
 * else **
 * { divide(stanga, dreapta, mijloc); **
 * if(val==v[mijloc]) sol=mijloc; **
 * else **
 * { if(val>n; for(i=1;i<=n;++i) f>>v[i]; f>>val; g<<sol; f.close; g.close; return 0; } || =**[|QuickSort- Sortare rapida]**=
 * CautareBinara(1,n,v,val,sol);**
 * (ca in manual....)**

(principiul arderii lumanarii la ambele capete ..principiul lui Hoare- algoritm din cartea lui Donald Knuth)
 * Varianta 2. QuickSort**

//**i**nclude // //using namespace std;// //ifstream f("date.in");// //ofstream g("date.out");// //int v[100],n;// //** void QuickSort(int stanga, int dreapta) **// //{// **pivot**=elementul din mijloc, caut din ambele capete pozitia in care elementele nu mai sunt in ordine- variabilele **i, j**

int pivot, mijloc,i,j,aux; mijloc=(stanga+dreapta)/2; pivot=v[mijloc];i=stanga;j=dreapta; while(i<=j) {while(v[i]pivot) j--; if(i<=j){aux=v[i];v[i]=v[j];v[j]=aux;i++;j--;} } } int main { int i; f>>n; for(i=1;i<=n;++i) f>>v[i]; QuickSort(1,n); for(i=1;i<=n;++i) g<<v[i]<<" "; f.close; g.close; return 0; } sir initial 3 8 1 3 5 2 se face interschimbarea lui 3 cu 1 limitele actuale sunt: i= 2 j=2 stanga: 1 dreapta 6 1 8 3 3 5 2 limitele actuale sunt: i= 2 j=1 stanga: 1 dreapta 6 1 8 3 3 5 2 se face interschimbarea lui 8 cu 2 limitele actuale sunt: i= 3 j=5 stanga: 2 dreapta 6 1 2 3 3 5 8 se face interschimbarea lui 3 cu 3 limitele actuale sunt: i= 4 j=3 stanga: 2 dreapta 6 1 2 3 3 5 8 se face interschimbarea lui 2 cu 2 limitele actuale sunt: i= 3 j=1 stanga: 2 dreapta 3 1 2 3 3 5 8
 * if(stanga<j)QuickSort(stanga,j); **
 * if(i<dreapta) QuickSort(i,dreapta) **;
 * sir initial**
 * pivot=1**
 * pivot=3**
 * pivot=2**

se face interschimbarea lui 5 cu 5 limitele actuale sunt: i= 6 j=4 stanga: 4 dreapta 6 1 2 3 3 5 8 1 2 3 3 5 8 || //"// **Turnul din Hanoi** sau **Turnurile din Hanoi** este un [|joc matematic] sau [|puzzle] . Este format din trei tije și un număr variabil de discuri, de diferite mărimi, care pot fi poziționate pe oricare din cele 3 tije. Jocul începe având discurile așezate în stivă pe prima tijă, în ordinea mărimii lor, astfel încât să formeze un turn. Scopul jocului este acela de a muta întreaga stivă de pe o tijă pe alta, respectând următoarele reguli: =*numărul total de mutări necesare ==
 * pivot=5**
 * =// [|Turnurile din Hanoi] //=
 * Doar un singur disc poate fi mutat, la un moment dat.
 * Fiecare mutare constă în luarea celui mai de sus disc de pe o tija și glisarea lui pe o altă tijă, chiar și deasupra altor discuri care sunt deja prezente pe acea tijă.
 * Un disc mai mare nu poate fi poziționat deasupra unui disc mai mic //" //

https://en.wikipedia.org/wiki/Tower_of_Hanoi Vizualizare grafică aici || ==//[]//==

codul sursă
using namespace std; long nr; //nr= numar totale mutari {if(n==1) {cout<>n; cout<<endl<<nr; return 0;
 * 1) include
 * void hanoi(int n,char a,char b, char c)**
 * hanoi(n-1,c,b,a);**
 * hanoi(n,a,b,c);**

} || =//**MergeSort**//=

media type="custom" key="29019093"