Is there the way to reach the final box - GRAPH - c++

Question

There is the problem:
The first man 'g' (who starts first) has to reach the final box 'e', so that the second man 'l' (whenever he do) could't catch the first man. The men can go left, right, up, down or can stay.
For example:
Input:
6 7
RRRRRRR
R_e___R
R_____R
R_RRR_R
R_gRl_R
RRRRRRR
The answer is "YES" because there is the way (Left, Up, Up, Up, Right).
How this problem can be implemented?
I'm using BFS and DFS.
Here is my code
#include <iostream>
#include <algorithm>
#include <stack>
#include <math.h>
#include <cstring>
#include <map>
#include <queue>
using namespace std;
const int MAX = 32;
char a[MAX][MAX];
int used[MAX][MAX], m1[MAX][MAX], m2[MAX][MAX];;
int movesx[8] = {-1, 1, 0, 0};
int movesy[8] = { 0, 0, -1, 1};
int n, m, c = 0, flag = 0;
struct pc {
int x, y;
};
pc li, ga, fi;
queue <pc> q;
void BFS1(pc v) {
pc from, to;
memset(m1,0,sizeof(m1)); m1[v.y][v.x] = 0;
memset(used, 0, sizeof(used));
q.push(v); used[v.y][v.x] = 1;
while(!q.empty())
{
from = q.front(); q.pop();
for(int i = 0; i < 4; ++i) {
int x = from.x + movesy[i], y = from.y + movesx[i];
if( (a[y][x] == ' ' || a[y][x] == 'g' ) && !used[y][x]) {
used[y][x] = 1;
m1[y][x] = m1[from.y][from.x] + 1;
pc temp;
temp.x = x;
temp.y = y;
q.push(temp);
}
}
}
}
void BFS2(pc v) {
pc from, to;
memset(m2,0,sizeof(m2)); m2[v.y][v.x] = 0;
memset(used, 0, sizeof(used));
q.push(v); used[v.y][v.x] = 1;
while(!q.empty())
{
from = q.front(); q.pop();
for(int i = 0; i < 4; ++i) {
int y = from.y + movesy[i], x = from.x + movesx[i];
if( (a[y][x] == ' ' || a[y][x] == 'l' ) && !used[y][x]) {
used[y][x] = 1;
m2[y][x] = m2[from.y][from.x] + 1;
pc temp;
temp.x = x;
temp.y = y;
q.push(temp);
}
}
}
}
void DFS(pc v) {
used[v.y][v.x] = 1;
for(int i = 0; i < 4; ++i) {
int x = v.x + movesx[i], y = v.y + movesy[i];
if(a[y][x] == 'e') {
c = 1;
flag = 1;
return;
}
if( (a[y][x] == ' ' ) && !used[y][x] && m2[y][x] < m1[y][x] && flag == 0 ) {
pc temp;
temp.x = x;
temp.y = y;
DFS(temp);
}
}
}
int main() {
c = 0, flag = 0;
memset(used, 0, sizeof(used));
memset(a, 'R', sizeof(a));
cin >> n >> m;
string s;
getline(cin, s);
for(int i = 0; i < n; ++i) {
getline(cin, s);
for(int j = 0; j < m; ++j) {
a[i][j] = s[j];
if(a[i][j] == 'g') {
ga.x = j;
ga.y = i;
}
else if(a[i][j] == 'l') {
li.x = j;
li.y = i;
}
else continue;
}
}
BFS1(li);
BFS2(ga);
memset(used, 0, sizeof(used));
DFS(ga);
if(c == 1) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
Here is the second code:
#include <iostream>
#include <algorithm>
#include <stack>
#include <math.h>
#include <cstring>
#include <map>
#include <queue>
using namespace std;
const int MAX = 32;
char a[MAX][MAX];
int used[MAX][MAX], m1[MAX][MAX], m2[MAX][MAX];;
int an[1002][MAX][MAX];
int movesx[8] = {-1, 1, 0, 0, 0};
int movesy[8] = { 0, 0, -1, 1, 0};
int n, m, c = 0, flag = 0;
struct pc {
int x, y;
};
pc li, ga;
void functionD() {
for(int z = 1; z <= 1000; ++z) {
for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
if(an[z - 1][i][j] == 1) {
int x, y;
for(int k = 0; k < 5; ++k) {
x = j + movesx[k];
y = i + movesy[k];
if(x < m && y < n && x >= 0 && y >= 0) {
if(a[y][x] != 'R' && a[y][x] != 'e') {
an[z][y][x] = 1;
}
}
}
}
}
}
}
}
void DFS(pc v, int k) {
used[v.y][v.x] = 1;
for(int i = 0; i < 5; ++i) {
int x = v.x + movesx[i], y = v.y + movesy[i];
if(a[y][x] == 'e') {
c = 1;
flag = 1;
return;
}
if(an[k][y][x] == 0 && a[y][x] != 'R' && !used[y][x] && flag == 0 && k <= 1000) {
pc temp;
temp.x = x;
temp.y = y;
DFS(temp, k + 1);
}
}
}
int main() {
int nn; cin >> nn;
for(int z = 0; z < nn; ++z) {
c = 0, flag = 0;
memset(used, 0, sizeof(used));
memset(a, 'R', sizeof(a));
cin >> n >> m;
string s;
getline(cin, s);
for(int i = 0; i < n; ++i) {
getline(cin, s);
for(int j = 0; j < m; ++j) {
a[i][j] = s[j];
if(a[i][j] == 'g') {
ga.x = j;
ga.y = i;
}
else if(a[i][j] == 'l') {
li.x = j;
li.y = i;
}
}
}
an[0][li.y][li.x] = 1;
functionD();
DFS(ga, 1);
if(c == 1) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
}
EDIT (By Jarod42):
I found a tricky map which failed:
9 9
RRRRRRRRR
R...Rg..R
R.RlRRR.R
R.R...R.R
R.RRR.R.R
R.Re....R
R.R.RRR.R
R.......R
RRRRRRRRR
l cannot protect both accesses to e.
or even simpler
RRRRRRRRRR
R...RRRRRR
R.R...RRRR
RlReR...gR
R.R...RRRR
R...RRRRRR
RRRRRRRRRR

Answer 1

You have first to create a map distance from each accesses to e.
Then it is a minmax (or alpha-beta):
if g current position in one map-distance is less than l current position is same map-distance, g wins.
if l has less or equal distance in all maps distance, g loses.
else g has to use one of its valid map to reach the goal, l counters with its maps (or stands).
(Note: g has no reasons to stand as l may do the same and we are at the same point).
(Edit: Note: in provided link, it seems that the secure path has to be chosen statically, so the dynamic part (3rd bullet) is a loose for g)

Answer 2

There is no need for the DFS. Just test whether l can reach e before g can. If he can, then he can catch g, otherwise g wins.
(And beware of redundancy in your code; BFS1 and BFS 2 are almost identical, and could be combined into a single function.)
EDIT: The OP has added (a link to) new information: l cannot enter e.
The correction to this algorithm is obvious, if inelegant. Consider the rooms surrounding e; if there is one that g can reach before l, then g wins.
There may be other catches in the linked problem statement; the OP can state the problem he wants answered in the question itself. We don't like "link only" questions here.