每日一题(980. 不同路径 III)-回溯

最新推荐文章于 2024-04-23 16:46:02 发布

Bu9_Maker

最新推荐文章于 2024-04-23 16:46:02 发布

阅读量158

点赞数

分类专栏： Leetcode每日一题文章标签： leetcode python c++ 回溯

本文链接：https://blog.csdn.net/qq_39225746/article/details/132105973

版权

Leetcode每日一题专栏收录该内容

184 篇文章 0 订阅

订阅专栏

题目

980. 不同路径 III

题解思路

表格中值为1的为起始点
值为0 的是可以经过的点，但是只能经过一次
值为2 的是终点，
计算从起点到终点一共有多少种路径

计算出值为0的方格个数，同时找到起点位置
当位于终点时候且经过所有的方格为0的点即为一种路径

代码

C++

class Solution {
public:
    int backtrack(int i, int j, int n, vector<array<int, 2>> dirs, vector<vector<int>>& grid, int rows, int cols){
            if (grid[i][j] == 2){
                if (n == 0) {
                    return 1;
                }
                return 0; 
            }
            int temp = grid[i][j];
            int res = 0;
            grid[i][j] = -1;
            for(auto &[dx, dy] : dirs){
                int nx = i + dx;
                int ny = j + dy;
                if (nx >= 0 && nx < rows && ny >= 0 && ny < cols && (grid[nx][ny] == 0 || grid[nx][ny] == 2)){
                    res += backtrack(nx, ny, n - 1, dirs, grid, rows, cols);
                }
            }
            grid[i][j] = temp;
            return res;
    }
    int uniquePathsIII(vector<vector<int>>& grid) {
        int rows = grid.size(), cols = grid[0].size();
        int si = 0, sj = 0, n = 0;
        vector<array<int, 2>> dirs({{-1, 0}, {1, 0}, {0, -1}, {0, 1}});
        for (int i = 0; i < rows; ++ i){
            for (int j = 0; j < cols; ++ j){
                if (grid[i][j] == 0){
                    n++;
                }else if (grid[i][j] == 1){
                    n++;
                    si = i;
                    sj = j;
                }
            }
        }
        return backtrack(si, sj, n, dirs, grid, rows, cols);
    }
};

Python

class Solution:
    def uniquePathsIII(self, grid: List[List[int]]) -> int:
        rows, cols = len(grid), len(grid[0])
        si, sj, n = 0, 0, 0
        for i in range(rows):
            for j in range(cols):
                if grid[i][j] == 0:
                    n += 1
                elif grid[i][j] == 1:
                    n += 1
                    si, sj = i, j 
        def backtrack(i, j, n):
            if grid[i][j] == 2:
                if n == 0:
                    return 1
                return 0
            temp = grid[i][j]
            grid[i][j] = -1
            res = 0
            for nx, ny in [[i - 1, j], [i + 1, j], [i, j - 1], [i, j + 1]]:
                if 0 <= nx < rows and 0 <= ny < cols and grid[nx][ny] in [0, 2]:
                    res += backtrack(nx, ny, n - 1)
            grid[i][j] = temp
            return res
        return backtrack(si, sj, n)