[Backtracking] [leetcode] le nombre de tous les chemins du point de départ au point d'arrivée

sujet:

Sur une grille bidimensionnelle, il existe 4 types de grilles:

• 1 représente le carré de départ. Et il n'y a qu'une seule case de départ.
• 2 signifie le carré de fin et il n'y a qu'un seul carré de fin.
• 0 signifie une case vide que nous pouvons traverser.
• -1 signifie un obstacle que nous ne pouvons pas surmonter.

Renvoie le nombre de chemins différents entre le carré de départ et le carré de fin lorsque vous marchez dans quatre directions (haut, bas, gauche et droite).

Chaque case sans obstacle doit être passée une fois, mais la même case ne peut pas être répétée dans un chemin .

Exemple 1:

Entrée: [[1,0,0,0], [0,0,0,0], [0,0,2, -1]]
Sortie: 2
Explication: Nous avons les deux chemins suivants:
1. (0 , 0), (0,1), (0,2), (0,3), (1,3), (1,2), (1,1), (1,0), (2,0 ), (2,1), (2,2)
2. (0,0), (1,0), (2,0), (2,1), (1,1), (0,1) , (0,2), (0,3), (1,3), (1,2), (2,2)

la source:

980. Chemin différent III

Idées de résolution de problèmes: retour en arrière

Trouvez d'abord la position de départ (x, y), et comptez le nombre de carrés vides, enregistrez-le comme cible, définissez une variable courante pour enregistrer le nombre de carrés actuellement passés, et accumulez à partir de 1 (le point de départ par défaut a été parcouru ).

• Les conditions / résultats de terminaison récursifs remplissent les conditions: le nombre de carrés passés = le nombre de carrés vides + 2 (1 point de départ, 1 point final)
• Conditions d'appel récursives: pour les carrés supérieur, inférieur, gauche et droit, s'il vaut 0, il récurera; s'il vaut 2 (c'est-à-dire le point final), il ne se répètera que lorsque tous les carrés vides seront traversés. Ceux qui ne remplissent pas les conditions sont considérés comme élagués.

Cette question ne renvoie que le nombre de résultats et ne sort pas la liste de résultats, donc ne définissez plus le chemin du chemin, modifiez-le directement sur la grille: mis à x avant récursivité (tant qu'il n'est pas 0,1,2, - 1) et restaurer après récursivité.

class Solution {
public:
    int result;
    int m, n;
    int uniquePathsIII(vector<vector<int>>& grid) {
        m = grid.size();
        n = grid[0].size();

        // 找出起始方格，统计空方格个数
        int target = 0;
        int x = 0, y = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0) target++;
                if (grid[i][j] == 1) {
                    x = i;
                    y = j;
                }
            }
        }
        result = 0;
        back(grid, x, y, 1, target+2);
        return result;
    }
    void back(vector<vector<int>>& grid, int x, int y, int current, int target) {
        if (current == target) {
            result++;
            return;
        }
        // 上下左右
        if (x > 0) {
            int t = grid[x-1][y];
            if (t == 0 || (current + 1 == target && t == 2)) {
                grid[x-1][y] = 3;
                back(grid, x-1, y, current+1, target);
                grid[x-1][y] = t;
            }
        }
        if (x + 1 < m) {
            int t = grid[x+1][y];
            if (t == 0 || (current + 1 == target && t == 2)) {
                grid[x+1][y] = 3;
                back(grid, x+1, y, current+1, target);
                grid[x+1][y] = t;
            }
        }
        if (y > 0) {
            int t = grid[x][y-1];
            if (t == 0 || (current + 1 == target && t == 2)) {
                grid[x][y-1] = 3;
                back(grid, x, y-1, current+1, target);
                grid[x][y-1] = t;
            }
        }
        if (y + 1 < n) {
            int t = grid[x][y+1];
            if (t == 0 || (current + 1 == target && t == 2)) {
                grid[x][y+1] = 3;
                back(grid, x, y+1, current+1, target);
                grid[x][y+1] = t;
            }
        }
    }
};