leetcode四杀——机器人路径系列

最新推荐文章于 2022-07-23 19:38:14 发布

星回昭以烂

最新推荐文章于 2022-07-23 19:38:14 发布

阅读量879

点赞数

分类专栏：刷题文章标签： leetcode 动态规划回溯

本文链接：https://blog.csdn.net/m0_51013067/article/details/124199186

版权

刷题专栏收录该内容

16 篇文章 1 订阅

订阅专栏

本文介绍了LeetCode上的几道经典动态规划和回溯算法题目，包括不同路径问题和机器人运动范围问题。文章详细分析了不同解法，如自顶向下和自底向上迭代，以及如何利用动态规划和回溯策略解决障碍和迷宫问题。同时，还探讨了无后效性在动态规划中的应用。

摘要由CSDN通过智能技术生成

文章目录

不同路径

62. 不同路径 - 力扣（LeetCode） (leetcode-cn.com)

状态转移方程：到达(x, y) 的路径数等于到达(x - 1, y)和(x, y - 1) 路径数之和
dp定义：从(0, 0)到 (x, y)有 dp(x, y)条路径

写法一：

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        //注意该题初始化
        for(int i = 0; i < m; i++){
            dp[i][0] = 1;
        }
        for(int i = 0; i < n; i++){
            dp[0][i] = 1;
        }
        for(int i = 1 ; i < m ; i++){
            for(int j = 1; j < n; j++){
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
}

写法二：

public int uniquePaths(int m, int n) {
    return dp(m - 1, n - 1);
}

int dp(int x, int y) {
    if (x == 0 && y == 0) {
        return 1;
    }
    if (x < 0 || y < 0) {
        return 0;
    }
    return dp(x - 1, y) + dp(x, y - 1);
}

不同路径||

63. 不同路径 II - 力扣（LeetCode） (leetcode-cn.com)

此题和上一题相比只是多了一个“障碍”条件，状态转移方程不变，只是注意要在遇到障碍时候dp[i][j]保持0

写法一：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];
        //注意该题初始化
        //初始化的部分，很容易忽略了障碍之后应该都是0的情况
        for(int i = 0; i < m; i++){
            //一旦遇到障碍，后续都无法到达了
            if(obstacleGrid[i][0] == 1){
                break;
            }
            dp[i][0] = 1;
        }
        for(int i = 0; i < n; i++){
            //一旦遇到障碍，后续都无法到达了
            if(obstacleGrid[0][i] == 1){
                break;
            }
            dp[0][i] = 1;
        }
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                //遇到障碍dp[i][j]保持0
                if(obstacleGrid[i][j] == 1){
                    continue;
                }
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
}

写法二：自顶向下递归

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        memo = new int[m][n];//备忘录
        return dp(obstacleGrid, m - 1, n - 1);
    }

    // 备忘录
    int[][] memo;

    // 定义：从 grid[0][0] 出发到达 grid[i][j] 的路径条数为 dp(grid, i, j)
    int dp(int[][] grid, int i, int j) {
        int m = grid.length, n = grid[0].length;
        // base case
        if (i < 0 || i >= m || j < 0 || j >= n
                || grid[i][j] == 1) {
            // 数组越界或者遇到阻碍
            return 0;
        }
        if (i == 0 && j == 0) {
            // 起点到起点的路径条数就是 1
            return 1;
        }
        if (memo[i][j] > 0) {
            // 避免冗余计算
            return memo[i][j];
        }
        // 状态转移方程：
        // 到达 grid[i][j] 的路径条数等于
        // 到达 grid[i-1][j] 的路径条数加上到达 grid[i][j-1] 的路径条数
        int left = dp(grid, i, j - 1);
        int upper = dp(grid, i - 1, j);
        int res = left + upper;
        // 存储备忘录
        memo[i][j] = res;
        return res;
    }
}

写法三：自底向上迭代

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        // 数组索引偏移一位，dp[0][..] dp[..][0] 代表 obstacleGrid 之外
        // 定义：到达 obstacleGrid[i][j] 的路径条数为 dp[i-1][j-1]
        int[][] dp = new int[m + 1][n + 1];
        // base case：如果没有障碍物，起点到起点的路径条数就是 1
        dp[1][1] = obstacleGrid[0][0] == 1 ? 0 : 1;

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == 1 && j == 1) {
                    // 跳过 base case
                    continue;
                }
                if (obstacleGrid[i - 1][j - 1] == 1) {
                    // 跳过障碍物的格子
                    continue;
                }
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        // 返回到达 obstacleGrid[m-1][n-1] 的路径数量
        return dp[m][n];
    }
}

写法四：优化二维dp数组为一维dp数组

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        // 根据二维 dp 数组优化为一维 dp 数组
        int[] dp = new int[n + 1];
        dp[1] = obstacleGrid[0][0] == 1 ? 0 : 1;

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (i == 1 && j == 1) {
                    // 跳过 base case
                    continue;
                }
                if (obstacleGrid[i - 1][j - 1] == 1) {
                    // 跳过障碍物的格子
                    dp[j] = 0;
                    continue;
                }
                dp[j] = dp[j] + dp[j - 1];
            }
        }
        // 返回到达 obstacleGrid[m-1][n-1] 的路径数量
        return dp[n];
    }
}

迷路的机器人

面试题 08.02. 迷路的机器人 - 力扣（LeetCode） (leetcode-cn.com)

回溯+路径记录：

class Solution {
    boolean[][] visited;
    List<List<Integer>> pathList;
    public List<List<Integer>> pathWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        visited = new boolean[m][n];
        pathList = new ArrayList<>();
        dfs(0, 0, obstacleGrid);
        return pathList;
    }
    //参数：横纵坐标
    private boolean dfs(int row, int col, int[][] obstacleGrid){
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        //异常情况：行坐标超出范围 || 列坐标超出范围 || 格子里面是障碍物 || 已经访问过这个格子
        if(row >= m || col >= n || obstacleGrid[row][col] == 1 || visited[row][col]){
            return false;
        }
        //不是以上情况，说明这份格子值得探索，所以做出选择
        pathList.add(Arrays.asList(row, col));
        //将格子标记为已经历
        visited[row][col] = true;
        //已经到达最后一个格子：
        if(row == m - 1 && col == n - 1){
            return true;
        }
        //选择后没到最后一个格子：
        //如果右边格子或者下边格子是true的话，返回true。
        //先尝试向下，再尝试向右：
        //神奇的或运算
        //这里有一点需要注意，因为||的性质，前者为true的时候，就先不执行右格了。
        //只有下格之后的路径难以为继的时候，才会来这里继续执行右格
        if(dfs(row + 1, col, obstacleGrid) || dfs(row, col + 1, obstacleGrid)){
            return true;
        }
        //如果已经到了末路，即当前格子没有障碍，
        //但右、下格子都是障碍的话，但还没有到达最后的格子，
        //穷途末路，到了死胡同，就要撤销选择，回头是岸
        //此时删掉数组pathList的最后一个元素。并返回false
        pathList.remove(pathList.size() - 1);
        return false;
    }
}

注意这道题有一个坑，孩子已经跳进去一回了！！！！就是回溯的时候visited不用设置回false，实际上，这道题的约束条件：机器人只能向右或向下走，产生了最为关键的影响。以下解释摘自leetcode题解区域。

链接：https://leetcode-cn.com/problems/robot-in-a-grid-lcci/solution/cong-wu-hou-xiao-xing-yuan-lai-nong-dong-spqj/

不管我之前是怎么到达(row, col)这个坐标的，我在选择要走到别的格子的时候，只能向下或向右，和之前怎么走到(row, col)是无关的。那么可以推出：如果我曾经经过(row, col)这个坐标，并且继续往下走得很深，但是最终失败了，那么当我再次从别的格子走到(row, col)时，也就没有必要继续往下搜了，因为它接下来还是只能往下或往右走，并且最终一定会失败，那么也就没有必要接着走到(row, col)，所以也没有必要在回溯的时候，把visited[row][col]设为false了。
这里牵扯到了动态规划里面的一个基本原理：无后效性。
简单点说，就是我T时间到达了某个状态，在对后面要到达什么的状态进行决策的时候，和T时间之前的决策没有关系，也可以说，T时间之前的决策，对T时间之后的决策，不会产生任何影响。
所以如果这个题目的条件改为每个格子的上下左右都可以走，就不满足无后效性了。

可以这样分析，假设我现在在(row, col)这个位置，并且是从上面的格子(row - 1, col)过来的，那么我从(row, col)接着走，就只能往下、左、右这三个方向，其他方向也是同理，有以下关系：
- (row - 1, col) - > (row, col)，上边过来，接下来的决策方向：下、左、右
- (row, col - 1) - > (row, col)，左边过来，接下来的决策方向：上、下、右
- (row + 1, col) - > (row, col)，下边过来，接下来的决策方向：上、左、右
- (row, col + 1) - > (row, col)，右边过来，接下来的决策方向：上、下、左
从列表中我们可以看到，(row, col)前的决策不同的话，(row, col)后的决策也是不同的，也就是说，(row, col)前的决策，会影响(row, col)后的决策，所以也就不满足无效性这个性质。
本题满足无后效性，当然能通过动态规划来求解，如果换了条件（上下左右）就只能用回溯来做了，动态规划想都不要想了！！！

动态规划版本：

dp定义：dp[i][j]表示能否到达(i, j)
路径转移：
- obstacleGrid[i][j] = 1： d[i][j] = false
- obstacleGrid[i][j] = 0：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])，这里用或运算表示

class Solution {
    public List<List<Integer>> pathWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;
        List<List<Integer>> pathList = new ArrayList<>();
        //dp[i][j]表示能否到达i, j
        boolean[][] dp = new boolean[m][n];
        if(obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1){
            return pathList;
        }
        //初始化：原点、首行、首列
        dp[0][0] = true;
        for(int i = 1; i < m; i++){
            dp[i][0] = (obstacleGrid[i][0] == 0) && dp[i - 1][0];
        }
        for(int i = 1; i < n; i++){
            dp[0][i] = (obstacleGrid[0][i] == 0) && dp[0][i - 1];
        }
        //计算
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                dp[i][j] = (obstacleGrid[i][j] == 0) && (dp[i - 1][j] || dp[i][j - 1]);
            }
        }
        //终点不可达:返回空数组
        if(dp[m - 1][n - 1] == false){
            return pathList;
        }
        //终点可达，倒序计算
        int i = m - 1, j = n - 1;
        while(i > 0 || j > 0){
            pathList.add(Arrays.asList(i, j));
            if(i > 0 && dp[i - 1][j]){
                i--;
            }else{
                j--;
            }
        }
        //插入起点
        pathList.add(Arrays.asList(0, 0));
        Collections.reverse(pathList);
        return pathList;
    }
}

机器人的运动范围

剑指 Offer 13. 机器人的运动范围 - 力扣（LeetCode） (leetcode-cn.com)

class Solution {
    public int movingCount(int m, int n, int k) {
        boolean[][] visited = new boolean[m][n];
        return dfs(0, 0, m, n, k, visited);
    }

    private int dfs(int i, int j, int m, int n, int k, boolean visited[][]) {
        if (i < 0 || i >= m || j < 0 || j >= n || (i/10 + i%10 + j/10 + j%10) > k || visited[i][j]) {
            return 0;
        }
        visited[i][j] = true;
        return dfs(i + 1, j, m, n, k, visited) + dfs(i - 1, j, m, n, k, visited) + 
               dfs(i, j + 1, m, n, k, visited) + dfs(i, j - 1, m, n, k, visited) + 1;
    }
}

优化：

这道题由于是从原点开始移动的，所以可以简化成向下、向右移动；
顺便这里把多于两位数的数位之和的计算补充一下。

class Solution {
    public int movingCount(int m, int n, int k) {
        boolean[][] visited = new boolean[m][n];
        return dfs(0, 0, m, n, k, visited);
    }
    public int dfs(int i, int j, int m, int n, int k, boolean[][] visited) {
        if(i >= m || j >= n || k < getSum(i) + getSum(j) || visited[i][j]) {
            return 0;
        }
        visited[i][j] = true;
        return 1 + dfs(i + 1, j, m, n, k, visited) + dfs(i, j + 1, m, n, k, visited);
    }

    private int getSum(int a) {
        int sum = a % 10;
        int tmp = a / 10;
        while(tmp > 0) {
            sum += tmp % 10;
            tmp /= 10;
        }
        return sum;
    }
}

知识小点：Arrays.asList()

Arrays.asList() 详解 - 简书 (jianshu.com)

今日推歌

-----《海平面的星》

你给的爱是
飘忽海平面上的星星
再美丽也是种倒影
谁脚步轻盈
编织若有似无的爱情
你离开我的心却永远
无法风平浪静

星回昭以烂

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
leetcode四杀——机器人路径系列

文章目录不同路径不同路径||迷路的机器人机器人的运动范围知识小点：Arrays.asList()今日推歌不同路径62. 不同路径 - 力扣（LeetCode） (leetcode-cn.com)状态转移方程：到达(x, y) 的路径数等于到达(x - 1, y)和(x, y - 1) 路径数之和dp定义：从(0, 0)到 (x, y)有 dp(x, y)条路径写法一：class Solution { public int uniquePaths(int m, int n) {
复制链接

扫一扫