Lee-Algoritm Realizat:Dinu Adrian PaP1813

Lee-Algoritm

Fiind dat un labirint sub forma matricei dreptunghiulare

binare, găsiți lungimea celei mai scurte căi într-un labirint
de la sursa dată la destinația dată.
Cum lucreaza?

Calea poate fi construită doar din celule având valoarea 1 și,

în orice moment, putem muta doar un pas într-una din cele
patru direcții. Mișcările valide sunt:

Go Up: (x, y) –> (x – 1, y)

Go Left: (x, y) –> (x, y – 1)
Go Down: (x, y) –> (x + 1, y)
Go Right: (x, y) –> (x, y + 1)

 
 Complexitate:

Am discutat deja despre o soluție de backtracking în postarea

anterioară. Complexitatea în timp a soluției de backtracking de
mai sus va fi mai mare, deoarece toate căile trebuie parcurse.
Cu toate acestea, având în vedere că este o problemă pe cea
mai scurtă cale, BFS ar fi o alegere ideală.
Algoritmul Lee este o soluție posibilă pentru problemele de rutare labirintică
bazate pe prima căutare a Lărgimii. Dă întotdeauna o soluție optimă, dacă
există, dar este lent și necesită o memorie considerabilă. Mai jos este
algoritmul complet :

Creați o coadă goală și căutați o celulă sursă la distanță 0 de la sursă (în sine)
și marcați-o ca vizitată:
 
1.Faceți până când coada nu este goală
2.Pop nod din față din coadă 
3.Dacă nodul popped este nodul de destinație,
4.Atunci întoarceți distanța acestuia altceva pentru fiecare din cele 4 celule
adiacente ale celulei curente,
5.Introducem fiecare celulă valabilă în coadă cu +1 distanță și le marcăm ca
vizitate 
6. Dacă toate nodurile din coadă sunt procesate și destinația nu este atinsă,
atunci returnează false
#include <iostream>
#include <queue>
#include <climits>
#include <cstring>
using namespace std;

// M x N matrix
#define M 10
#define N 10

// queue node used in BFS

struct Node
{
// (x, y) represents matrix cell coordinates
// dist represent its minimum distance from the source
int x, y, dist;
};

// Below arrays details all 4 possible movements from a cell

int row[] = { -1, 0, 0, 1 };
int col[] = { 0, -1, 1, 0 };

// Function to check if it is possible to go to position (row, col)

// from current position. The function returns false if (row, col)
// is not a valid position or has value 0 or it is already visited
bool isValid(int mat[][N], bool visited[][N], int row, int col)
{
return (row >= 0) && (row < M) && (col >= 0) && (col < N)
&& mat[row][col] && !visited[row][col];
}
void BFS(int mat[][N], int i, int j, int x, int y)
{
// construct a matrix to keep track of visited cells
bool visited[M][N];

// initially all cells are unvisited

memset(visited, false, sizeof visited);

// create an empty queue

queue<Node> q;

// mark source cell as visited and enqueue the source node

visited[i][j] = true;
q.push({ i, j, 0 });

// stores length of longest path from source to destination

int min_dist = INT_MAX;

// run till queue is not empty

while (!q.empty())
{
// pop front node from queue and process it
Node node = q.front();
q.pop();

// (i, j) represents current cell and dist stores its

// minimum distance from the source
int i = node.x, j = node.y, dist = node.dist;
// if destination is found, update min_dist and stop
if (i == x && j == y)
{
min_dist = dist;
break;
}

// check for all 4 possible movements from current cell

// and enqueue each valid movement
for (int k = 0; k < 4; k++)
{
// check if it is possible to go to position
// (i + row[k], j + col[k]) from current position
if (isValid(mat, visited, i + row[k], j + col[k]))
{
// mark next cell as visited and enqueue it
visited[i + row[k]][j + col[k]] = true;
q.push({ i + row[k], j + col[k], dist + 1 });
}
}
}

if (min_dist != INT_MAX)
cout << "The shortest path from source to destination "
"has length " << min_dist;
else
cout << "Destination can't be reached from given source";
}
// Shortest path in a Maze
int main()
{
// input maze
int mat[M][N] =
{
{ 1, 1, 1, 1, 1, 0, 0, 1, 1, 1 },
{ 0, 1, 1, 1, 1, 1, 0, 1, 0, 1 },
{ 0, 0, 1, 0, 1, 1, 1, 0, 0, 1 },
{ 1, 0, 1, 1, 1, 0, 1, 1, 0, 1 },
{ 0, 0, 0, 1, 0, 0, 0, 1, 0, 1 },
{ 1, 0, 1, 1, 1, 0, 0, 1, 1, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 1, 0, 1 },
{ 0, 1, 1, 1, 1, 1, 1, 1, 0, 0 },
{ 1, 1, 1, 1, 1, 0, 0, 1, 1, 1 },
{ 0, 0, 1, 0, 0, 1, 1, 0, 0, 1 },
};

// Find shortest path from source (0, 0) to

// destination (7, 5)
BFS(mat, 0, 0, 7, 5);

return 0;
}
Concluzii

Cei mai rapizi algoritmi sunt cei logaritmici.

Daca pentru rezolvarea aceleiasi probleme exista algoritmi
polinomiali si exponentiali,se prefera cei polinomiali.
Daca pentru rezolvarea aceleiasi probleme exista mai multi
algoritmi polinomiali,se prefera cel cu grad mai mic.