Documente Academic
Documente Profesional
Documente Cultură
INTERDISCIPLINARITATEA
b. Componenta 2 va memora 1 1 1
c. Nu există permutări care încep 1, 1, motiv pentru care, pentru aceeași componentă, vom
reține valoarea următoare, adică 2. Întrucât există permutări care încep cu 1, 2, vom trece
la elementul 3. Pas înainte. 1 2
d. Componenta 3 va memora 1 1 2 1
e. Nu există permutări care sunt de forma 1, 2, 1, motiv pentru care are component va reține
numărul următor, 2. 1 2 3
f. Nu există permutări care sunt de forma 1, 2, 2, motiv pentru care aceeași componentă va
memora numărul următor, adică 3. Am obținut o primă soluție și o afișăm. 1 2 3
h. Din acest motiv vom trce la elementul 2. Pas înapoi. Componenta 2 are déjà valoarea
memorată 2. Alegem valoarea următoare 3. Întrucât există permutări care încep cu 1, 3,
vom trece la elementul următor 3. Trecem la valoarea 2, intrucît nu există permutări de
forma 1, 3, 1. Așadar, obținem soluția 1, 3, 2 și o afișăm. 1 3 2
void back(int k)
{
if (solutie(k)) tipar ();
else
{ init (k);
while (successor (k))
if (valid (k) ) back(k+1);
}
}
Inițial se testează dacă s-a generat o soluție. Pentru aceasta, se apelează subprogramul soluție(k).
Cum subprogramul este recursiv, acest fapt se întâmplă când s-a ajuns la nivelul n+1.
Dacă s-a obținut o soluție, aceasta se afișează. Pentru această operație se va utiliza
subprogramul tipar.
În situația în care nu a fost obținută o soluție, se inițializează nivelul k. Inițializarea se
face cu valoarea aflată înaintea tuturor valorilor posibile. Se va folosi subprogramul init.
Pentru permutări inițializarea se face cu 0.
După inițializare, se generează, pe rând, toate valorile mulțimii Ak. Pentru aceasta se
utilizează subprogramul succesor. Rolul său este de a atribui componentie k valoarea
celei deja existente.
Pentru fiecare valoare generată, se testează dacă aceasta îndeplinește condiția de
continuitate. Acest test este realizat de subprogramul valid.
În cazul în care condițiile sunt îndeplinite, se trece la componenta k+1, urmând ca
generarea valorilor pe nivelul k, să continue atunci când se revine pe acest nivel.
Dacă condițiile de continuare nu sunt îndeplinite, se generează următoarea valoare
pentru componenta k.
După ce au fost generate toate valorile mulțimii Ak se trece, implicit, la componenta k-1, iar
algoritmul se încheie când k=0.
#include <iostream>
using namespace std;
int n, sol[10];
void init(init k)
{ sol[k]=0;
}
int successor(int k)
{ if (sol[k]<n)
{ sol[k]++;
return 1; }
else return 0;
}
int valid(int k)
{ int I, ev=1;
for (i=1;i<=k-1;i++)
if (slo[k]==sol[i]) ev=0;
return 0;
}
int solutie(int k)
{ return k==n+1;
}
void tipar ( )
{ for (int i=1;i<=n;i++)
cout<<sol[i];
cout<<endl;
}
void back(int k)
{ if (solutie(k)) tipar( );
else
{ init(k);
while (succesor(k))
if (valid(k)) back(k+1);
}
}
int main()
{ cout<<”n=”; cin>>n; back(1);
return 0;
}
Se dau două mulțimi A={1, 2, 3, …., p} și B={1, 2, 3, …., n}. Se cer toate toate funcțiile
injective definite pe A cu valori în B. o astfel de problemă este una de generare a aranjamentelor
𝑝
de n luate câte p (𝐴𝑛 ).
Exemplu: p=2; n=3. Avem: 12,21,13,31,23,32. De exemplu, 21 este funcția f: AB dată
astfel: f(1)=2; f(2)=1; Avem relațiile:
𝑝 𝑛!
𝐴𝑛 = (𝑛−𝑝)! = n(n-1).......(n-p+1)
CONCLUZIE