【ACWing】1112. Labyrinth

Subject address:

https://www.acwing.com/problem/content/1114/

One day Extense accidentally walked into a maze while exploring the forest. The maze can be seen as $n\ast n$ grid points, each grid point is only$Two$ states,.and#, the former means that it is passable and the latter means it is not passable. At the same time, when Extense is at a certain grid point, he can only move to one of the adjacent grid points in one of the four directions, southeast, northwest (or up, down, left, and right). Extense wants to move from point$A$ goes to point$B$ , ask if it can be done without getting out of the maze. If either the starting point or the end point is impassable (#Yes), it is regarded as impossible. Note:$A$、$B\; is$ not necessarily two different points.

Input format:
No. $1$ line is the number of groups of test data$k$ followed by$K$ group input. The first1 ofeach set of test data$1$ line is a positive integer$n$ , which means the scale of the maze is$n\ast n$ . Next is a$n\ast n$ matrix, the elements in the matrix are.or#. The next line is$4$ integers$h_a,l_a,h_b,l_b$, Describe $A$ is in the first$h_a$Line, $l_a$Column, $B$ is in$h_b$Line, $l_b$Column. Note that $h_a,l_a,h_b,l_b$All from $0$ starts counting.

Output format:
$k$ lines, each line of output corresponds to one input. If it can be done, it will output "YES", otherwise it will output "NO".

Data range:
$1\le n\le 100$

It can be directly from the starting point DFS, if the end point can be searched, it will output YES, otherwise it will output NO. Pay attention to #the situation where the starting point or the end point needs to be judged . code show as below:

#include <iostream>
#include <cstring>
using namespace std;

const int N = 110, d[] = {
    
    1, 0, -1, 0, 1};
char a[N][N];
bool st[N][N];
int n;
int sx, sy, ex, ey;

bool dfs(int x, int y) {
    
    
    if (x == ex && y == ey) return true;

    st[x][y] = true;
    for (int i = 0; i < 4; i++) {
    
    
        int nx = x + d[i], ny = y + d[i + 1];
        if (0 <= nx && nx < n && 0 <= ny && ny < n && a[nx][ny] != '#' && !st[nx][ny]) 
            if (dfs(nx, ny)) return true;
    }

    return false;
}

int main() {
    
    
    int T;
    cin >> T;
    while (T--) {
    
    
        cin >> n;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                cin >> a[i][j];
        cin >> sx >> sy >> ex >> ey;

        memset(st, false, sizeof st);

        bool res = false;
        if (a[sx][sy] == '#' || a[ex][ey] == '#') res = false;
        else res = dfs(sx, sy);

        cout << (res ? "YES" : "NO") << endl;
    }

    return 0;
}

Time and space complexity of each case $O(n^2)$。