【ACWing】 1076. Problème de labyrinthe

Adresse du sujet:

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

Étant donné un $n\times$Le tableau bidimensionnel de$n$ est le suivant:

int maze[5][5] = {

0, 1, 0, 0, 0,

0, 1, 0, 1, 0,

0, 0, 0, 0, 0,

0, 1, 1, 1, 0,

0, 0, 0, 1, 0,

};

Il représente un labyrinthe, où $1$ signifie mur,$0$ signifie que vous pouvez marcher, vous ne pouvez marcher que horizontalement ou verticalement, pas en diagonale. Cela nécessite une programmation pour trouver l'itinéraire le plus court du coin supérieur gauche au coin inférieur droit. Les données garantissent qu'il existe au moins un chemin entre le coin supérieur gauche et le coin inférieur droit.

Format d'entrée: la
première ligne contient l'entier $n$ . Nnsuivant$n$ lignes, chaque ligne contient$n$ entiers$0$ ou$1$ , ce qui signifie le labyrinthe.

Format de
sortie : affiche le chemin le plus court du coin supérieur gauche au coin inférieur droit. Si la réponse n'est pas unique, affiche un chemin. Dans l'ordre, chaque ligne sort les coordonnées des cellules passant dans le chemin, les coordonnées du coin supérieur gauche sont $(0,0)$ , les coordonnées du coin inférieur droit sont$(n-1,n-1)$。

Plage de données:
$0\le n\le 1000$

Les deux côtés sont $1.$ Vous pouvez utiliser BFS pour trouver le chemin le plus court et utiliser un tableau$p$ pour enregistrer$p\left[i\right][j]\; De$ quelle grille provient cette grille? Lors de la recherche du chemin, poussez du point final au point de départ. Pour plus de commodité, vous pouvez également commencer directement à partir du point final$(n-1,n-1)$ Lancer la recherche, trouver le point de départ$(0,0)$ , donc lorsque le chemin est déduit de$(0,0)\; C\text{'}est$ parti. code montrer comme ci-dessous:

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

const int N = 1010, d[] = {
    
    1, 0, -1, 0, 1};
int n;
int a[N][N];
pair<int, int> pre[N][N];
queue<pair<int, int> > q;

void bfs(int x, int y) {
    
    
    q.push({
    
    x, y});
    // 未访问的点设为-1
    memset(pre, -1, sizeof pre);

    pre[x][y] = {
    
    x, y};
    while (!q.empty()) {
    
    
        auto t = q.front();
        q.pop();
        x = t.first, y = t.second;
        for (int i = 0; i < 4; i++) {
    
    
            int nx = x + d[i], ny = y + d[i + 1];
            // 出界了，略过
            if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
            // 略过障碍物
            if (a[nx][ny]) continue;
            // 访问过，则略过
            if (pre[nx][ny].first != -1) continue;

            q.push({
    
    nx, ny});
            pre[nx][ny] = t;
			
			// 搜到起点了，可以直接退出
            if (nx == 0 && ny == 0) return;
        }
    }
}

int main() {
    
    
    cin >> n;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            scanf("%d", &a[i][j]);

    bfs(n - 1, n - 1);
    pair<int, int> end = {
    
    0, 0};

    while (1) {
    
    
        printf("%d %d\n", end.first, end.second);
        if (end.first == n - 1 && end.second == n - 1) break;
        end = pre[end.first][end.second];
    }
    
    return 0;
}

Complexité temporelle et spatiale $O\left(n^2\right)$。