Modoran

Carmen
cl. a XI a A

Se dau dimensiunuile unei table de sah(n*n) si se cere

parcurgerea acesteia ,cunoscandu-se pozitia de
plecare a calului(memorata in variabilele x si y).De
asemenea,se cere sa se gaseasca varianta de
parcurgere care necesita cat mai putine mutari.

Am ales rezolvarea problemei prin

metoda Backtracking si metoda Greedy.
Avantajul metodei Backtracking este
acela ca ofera toate solutiile posibile de
parcurgere a tablei de sah,insa timpul
de executie este mai eficient in cazul
metodei Greedy,aceasta din urma
oferind doar o solutie.

1. Se va reprezenta tabla de sah ca o matrice (pozitiile tablei se vor

memora ca elementele matricei) vom lua exemplul unei table de sah
normale,adica n va fi egal cu 8
j
1 2 3 4 5 6 7 8

1
2
3
4
5
6
7
8

Linele le vom marca prin variabila i iar coloanele cu j

In exemplul dat,pozitia de pornire (x,y) este (2,3) x=2,y=3

Metoda Backtracking

#include <iostream>
using namespace std;
//vom crea o functie pentru afisarea matricei
unsigned int lab[101][101],x,y,n;
in care vom obtine rezultatul
void afisare()
//atat timp cat deplasarea calului
{ ofstream g(tabla.out);
se va realiza in interiorul tablei,adica nu va
for(unsigned int i=1;i<=n;i++)
iesi din tabla(se va deplasa intre patratelul
for(unsigned int j=1;j<=n;j++)g<<sah[i][j]<<" ";
(1,1) si (n,n) si atata timp cat nu a mai trecut
prin
acel loc(in matricea-rezultat,locul in ca nu
g<<endl; g.close();
a fost marcat cu numarul pasului,valoarea
}
ramanand egala cu 0,conditiile sunt indeplinite,
void traseu(unsigned int i,unsigned int j,
iar calul se poate deplasa
unsigned int k)
{
//matricearezultat,initia lavand valoarea tuturor
if(i>=1&&j>=1&&i<=n&&j<=n&&sah[i][j]==0) elementelor egala cu 0,va lua(in cazul in care conditiile
sunt indeplinite)valoarea numarului de ordine al pasului
{
curent(astfel se obtin exact locurile unde va fi mutat calul,
sah[i][j]=k;
in ordine)
if(k==n*n) afisare();
//in cazul in care numar de ordine al mutarii la care ne aflam este egal cu
Numarul total al casutelor tablei,inseamna ca am epuizat toate mutarile
Si am obtinut o varianta de parcurgere a tablei completain acest caz,
Varianta va fi afisata

traseu(i-1,j-2,k+1);
traseu(i-1,j+2,k+1);
traseu(i-2,j-1,k+1);
traseu(i-2,j+1,k+1);
traseu(i+1,j-2,k+1);
traseu(i+1,j+2,k+1);
traseu(i+2,j-1,k+1);
traseu(i+2,j+1,k+1);
}

lab[i][j]=0;

}
int main()
{cin>>n>>x>>y;
traseu(x,y,1);
return 0; }

//apelarea subprogramului de backtracking Se va efectua

in 8 modalitati,cresterea sau descresterea parametrilor i
si j determinand modalitatea de deplasare a calului in tabla
(adica in matrice);parametrul k reprezinta
Pasul curent ,acesta va ceste la fiecare etapa
si va marca ordinea parcurgerii in matrice

//citirea de la tastatura a numarului de linii

Respectiv de coloane a tablei si pozitiile de plecare
Ale calului

//apelarea in programul principal a

Subprogramului de backtracking,cu parametrii
Pozitiile de plecare(x,y) si pasul de la care se incepe
Traseul calului

Metoda Greedy cea mai buna varianta pentru problemele de optimizare.

In cazul acestor tipuri de probleme ,metoda gaseste optimul pentru
anumite date de test ,iar pentru alte date fie nu gaseste solutia si
raporteaza ca nu exista,fie ofera o solutie care nu este optima,caz in
care vorbim despre Greedy Euristic.

GREEDY EURISTIC
In cazul problemei noastre,se va utiliza Greedy euristic,

Metoda Backtracking

Metoda Greedy

Genereaza toate
Ofera o rezolvare
solutiile posibile de
rapida,sporind
rezolvare a problemei eficienta programului
Ofera intotdeauna si
solutia corecta

Necestita timp foarte

mare de executie

Nu garanteaza
intotdeauna ca
solutia corecta
Nu se revine

Caietul de notite
https://olidej.wikispaces.com/file/view/1
003+Greedy+Euristic.pdf