Problema labirintului

Se dă un labirint reprezentat sub forma unei matrice cu n linii şi m coloane, conţinând

doar valori 0 şi 1. O succesiune de 0(zero) reprezintă un drum iar o succesiune de 1(unu)
reprezintă un zid. Dintr-un punct iniţial, a cărui coordonate se citesc, porneşte o persoană. Să
se afişeze câte modalități sunt ca acea persoană să ajungă în pozitia finală, ştiind că
deplasarea se poate face doar prin valori 0 ale matricei, iar salturile de câte o poziție, se pot
face în stânga, dreapta, jos şi sus.

Se dă matricea care reprezintă labirintul, cu urmatoarea semnificatie:

 6 7 – dimensiunile
 4 1 – coordonatele de pornire în matrice
 2 6 – coordonatele de sosire în matrice
 o succesiune de 0, reprezintă o cale liberă, 1 reprezentând obstacolele

labirint.in labirint.out

6 7 8
0 0 0 0 0 0 0
0 1 1 1 1 0 0
0 0 0 0 1 1 0
0 1 1 0 1 0 0
0 1 1 0 1 0 1
0 0 0 0 0 0 0
4 1
2 6

De asemenea, în problemă se mai menționează și faptul că deplasarea se face doar în 4

direcții:

 Nord: (-1, 0)
 Est: (0, +1)
 Sud: (+1, 0)
 Vest: (0, -1)

Această deplasare poate fi exprimată prin doi vectori dl[] – deplasare pe linie și dc[] –
deplasare pe coloană, astfel :

Direcții : N E S V

const int dl[4] = {-1, 0, 1, 0};

const int dc[4] = {0, 1, 0, -1};
Prezentăm mai jos un program în care vom face bordarea matricei date prin introducerea
liniei 0 și n + 1, precum și a coloanei 0 si m + 1, cu obstacole(ziduri) reprezentate prin 1.
Condițiile de continuare se rezumă la a verifica doar dacă noul element ales al matricei prin
salt de un pas în una din cele patru directii(Nord, Est, Sud sau Vest) este 0 (cale liberă) :

#include <bits/stdc++.h>
#define Dim 15
using namespace std;
int n, m, i, j, A[Dim][Dim], nr, xi, yi, xf, yf, sol;
const int dl[4] = {-1, 0, 1, 0};
const int dc[4] = {0, 1, 0, -1};
void backplan(int x, int y, int k)
{
int i, xx, yy;
if(x == xf && y == yf)
sol ++;
else
for(i = 0; i < 4; i ++)
{
xx = x + dl[i];
yy = y + dc[i];
if(!A[xx][yy])
{
A[xx][yy] = k;
backplan(xx, yy, k + 1);
A[xx][yy] = 0;
}
}
}
int main()
{
ifstream f("labirint.in");
ofstream g("labirint.out");
f >> n >> m;
for(i = 1; i <= n; i ++)
for(j = 1; j <= m; j ++)
f >> A[i][j];
for(i = 0; i <= n + 1; i ++)
A[i][0] = A[i][m + 1] = 1;
for(i = 0; i <= m + 1; i ++)
A[0][i] = A[n + 1][i] = 1;
f >> xi >> yi >> xf >> yf;
A[xi][yi] = 1;
backplan(xi, yi, 2);
g << sol;
return 0;
}