/METODA

BACKTRACKI
NG
Realizat de:
Spînu Lavinia, grupa 3I
Verificat de:
Violeta Bogdanova, dr. lector universitar

INDEX.HTML
/Ce este metoda backtracking?
Metoda backtracking poate fi folosită în rezolvarea a diverse probleme. Este o metodă lentă, dar de
multe ori este singura pe care o avem la dispoziție.

Backtracking = “to go back to an earlier point in a sequence”

Rezolvarea problemelor cu următoarele proprietăţi:

• O soluţie are forma unui vector
• Mulţimile sunt finite având elemente aflate într-o relaţiede ordine bine stabilită
• Se caută soluţia/soluţiile valide în spaţiul tuturor soluţiilor
• Nu există altă rezolvare cu timp de rulare mai rapid

INDEX.HTML
Unde putem folosi metoda
backtracking?

Cu toții știm de Sudoku, o grilă în formă de pătrat cu nouă

căsuțe pe orizontală și nouă căsuțe pe verticală,
subdivizat în tot atâtea pătrate identice, numite regiuni.
Regula jocului spune ca fiecare rând, coloană sau
regiune nu trebuie să conțină decât o dată cifrele de la 1
la 9. Așadar, fiecare ansamblu trebuie să conțină cifrele
de la 1 la 9 o singură dată.
Pentru a soluționa aceasta metoda în programare prin
metoda backtracking, încercăm să completăm cifrele
una câte una. Ori de câte ori aflăm că cifra actuală
nu poate duce la o soluție, o eliminăm (backtrack) și
încercăm următoarea cifră. Aceasta este mai bună
decât abordarea naivă (generarea tuturor
combinațiilor posibile de cifre și apoi încercarea
fiecarei combinații una câte una), deoarece renunță
la un set de permutări ori de câte ori se întoarce.
Codul în C++
#include <iostream>

using namespace std;

#define N 9

{
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
cout << arr[i][j] << " ";
cout << endl;
}
}
//Verificăm dacă avem același
bool isSafe(int grid[N][N], int row,int col, int num)
{ număr în rânduri, coloane și apoi
for (int x = 0; x <= 8; x++) matrici de 3x3, dacă nu sunt
if (grid[row][x] == num)
return false; prezente returnăm fals.
for (int x = 0; x <= 8; x++)
if (grid[x][col] == num)
return false;

int startRow = row - row % 3,

startCol = col - col % 3;

for (int i = 0; i < 3; i++)

for (int j = 0; j < 3; j++)
if (grid[i + startRow][j + startCol] == num)
return false;

return true;
}
bool solveSudoku(int grid[N][N], int row, int col)
{
if (row == N - 1 && col == N)
return true;

if (col == N) {
row++;
col = 0;}
//Preia o grilă parțial completată și
if (grid[row][col] > 0)
return solveSudoku(grid, row, col + 1);
încercăripentru a atribui valori
tuturor locațiilor nealocate în o
for (int num = 1; num <= N; num++)
{ astfel de modalitate de a îndeplini
if (isSafe(grid, row, col, num))
{ cerinţele pentru soluționarea
grid[row][col] = num;
Sudokului (neduplicare pe
rânduri,coloane și casete).
if (solveSudoku(grid, row, col + 1))
return true;
}

grid[row][col] = 0;
}
return false;
}
int main()
{
int grid[N][N] = { //Output
{ 3, 0, 6, 5, 0, 8, 4, 0, 0 },
{ 5, 2, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 8, 7, 0, 0, 0, 0, 3, 1 },
{ 0, 0, 3, 0, 1, 0, 0, 8, 0 },
{ 9, 0, 0, 8, 6, 3, 0, 0, 5 },
{ 0, 5, 0, 0, 9, 0, 6, 0, 0 },
{ 1, 3, 0, 0, 0, 0, 2, 5, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 7, 4 },
{ 0, 0, 5, 2, 0, 6, 3, 0,
0 } };

if (solveSudoku(grid, 0, 0))
print(grid);
else
cout << "no solution exists " << endl;

return 0;
}
Alte probleme rezolvate prin metoda
Backtracking
Rat Maze (Labirint)
Ca și la Sudoku, vom crea o matrice care cu 0 și 1, unde 0 sunt
pătratele unde „șoarecele” nu poate trece, adică pereții
labirintului și 1 reprezintă drumul liber. Vom scrie o funcție
recursivă, care va urma o cale și va verifica dacă calea
ajunge sau nu la destinație. Dacă calea nu ajunge la
destinație, întoarceți-vă înapoi și încercați alte căi.
N Queen Problem
N Queen(jocul de Dame) este problema plasării a N regine de șah pe o
tablă de șah N×N, astfel încât să nu se atace două regine una pe
cealaltă. Plasăm reginile una câte una în coloane diferite, începând
din coloana din stânga și verifcăm dacă nu sunt confruntări. În
coloana curentă, dacă găsim un rând pentru care nu există
ciocnire, marchăm locul ca parte a soluției. Dacă nu găsim din
cauza ciocnirilor, atunci revenim înapoi și returnăm fals.
/BACKTRACKING vs GREEDY vs DIVIDE
ET IMPERA
/BACKTRACKING
Chiar daca eșuează, continuă
alte căi de soluționare a
problemei. Revine la inceputul
algoritmului și îl parcurge
din nou.
/DIVIDE ET
/GREEDY
IMPERA
Divide problema în părți
Începe din stânga și merge mai mici de același tip
după cea mai lungă cale și ccombină soluțiile
posibilă pentru a găsi subproblemelor într-o
soluția optimă. soluție a problemei
orginale.
INDEX.HTML
/MULȚUMESC
PENTRU
ATENȚIE