【剑指Offer记录】13_机器人的运动范围

最新推荐文章于 2024-09-16 21:30:36 发布
最新推荐文章于 2024-09-16 21:30:36 发布
阅读量867 收藏 10
点赞数 22
分类专栏： 剑指Offer记录 文章标签： 经验分享 笔记 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44185089/article/details/137097759
版权

文章目录

Part1. 我的思路和代码（80%）

刚开始感觉和上一个题（12_矩阵中的路径）是一样的，只是判断条件不同，该题是用坐标的数位和判断，于是按照上一题的做法写了代码。思路方面和上一题相仿：

起点选择： 只有(0, 0)位置。

搜索策略： 目前路径不为空时（为空表示所有路线遍历完毕），如果当前位置满足坐标的数位和条件，则依次向四个方向搜索一步（注意搜索的下一步不能超过方格边界，并且不能是目前搜索路径上搜索过的位置），否则回溯；同时如果当前位置已经向四个方向都搜索过，也回溯。

判断条件： 利用%运算提取每一位的值，计算坐标的数位和，判断是否满足阈值条件，见isAccessable()函数。

变量设置： 同样分为搜索路径信息、辅助标志两部分。前者包括path_rows、path_cols，记录目前搜索路径每个位置的坐标；后者包括flag和visited，都是二维数组，形状和方格区域相同，其中flag和上一题笔记中的作用相同，visited则仅表示是否搜索过，值为1表示搜索过，0表示没有，最后visited中1的数量即题目所求。

然而，该做法每个位置不一定只搜索一次，于是时间复杂度不是O(mn)，提交后通过80%的用例。

bool isAccessable(int cur_row, int cur_col, int rows, int cols, int threshold) { // 计算位置数位和，判断指定位置是否可以进入
    int sum = 0;
    int temp_row = cur_row;
    int temp_col = cur_col;

    while(temp_row){ // 计算坐标的数位之和
        sum += temp_row % 10;
        temp_row /= 10;
    }
    while(temp_col){
        sum += temp_col % 10;
        temp_col /= 10;
    }
    if(sum > threshold){
        return false;
    }

    return true;
}

bool isOnCurPath(int row, int col, vector<int>& path_rows, vector<int>& path_cols) { //判断指定位置是否在当前搜索路径中
    for(int i=0; i<path_rows.size(); i++){
        if(row==path_rows[i] && col==path_cols[i]){
            return true;
        }
    }

    return false;
}

int movingCount(int threshold, int rows, int cols) {
    int ans = 0;
    vector<int> path_rows;
    vector<int> path_cols;
    vector<vector<int> > flag;
    vector<vector<int> > visited;

    path_rows.push_back(0); // 初始化
    path_cols.push_back(0);
    vector<int> tempArr(cols, 0);
    for(int i=0; i<rows; i++){
        flag.push_back(tempArr);
        visited.push_back(tempArr);
    }
    while(!path_rows.empty()){ // 开始搜索
        int cur_row = path_rows.back();
        int cur_col = path_cols.back();
        if(flag[cur_row][cur_col] == 4){
            path_rows.pop_back();
            path_cols.pop_back();
            flag[cur_row][cur_col] = 0;
            if(!path_rows.empty()){
                cur_row = path_rows.back();
                cur_col = path_cols.back();
            }
            continue;
        }
        if(isAccessable(cur_row, cur_col, rows, cols, threshold)){
            visited[cur_row][cur_col] = 1;
            switch(flag[cur_row][cur_col]){
                case 0: // 向左
                    if(cur_col-1 >= 0 && !isOnCurPath(cur_row, cur_col-1, path_rows, path_cols)){
                        path_rows.push_back(cur_row);
                        path_cols.push_back(cur_col-1);
                    }
                    ++flag[cur_row][cur_col];
                    break;
                case 1: //向上
                    if(cur_row-1 >= 0 && !isOnCurPath(cur_row-1, cur_col, path_rows, path_cols)){
                        path_rows.push_back(cur_row-1);
                        path_cols.push_back(cur_col);
                    }
                    ++flag[cur_row][cur_col];
                    break;
                case 2: //向右
                    if(cur_col+1 < cols && !isOnCurPath(cur_row, cur_col+1, path_rows, path_cols)){
                        path_rows.push_back(cur_row);
                        path_cols.push_back(cur_col+1);
                    }
                    ++flag[cur_row][cur_col];
                    break;
                case 3: //向下
                    if(cur_row+1 < rows && !isOnCurPath(cur_row+1, cur_col, path_rows, path_cols)){
                        path_rows.push_back(cur_row+1);
                        path_cols.push_back(cur_col);
                    }
                    ++flag[cur_row][cur_col];
                    break;
                default:
                    break;
            }
        }
        else{
            path_rows.pop_back();
            path_cols.pop_back();
            flag[cur_row][cur_col] = 0;
            if(!path_rows.empty()){
                cur_row = path_rows.back();
                cur_col = path_cols.back();
            }
        }
    }
    for(int i=0; i<rows; i++){
        for(int j=0; j<cols; j++){
            if(visited[i][j] == 1){
                ++ans;
            }
        }
    }

    return ans;
}

Part2. 我的思路和代码（100%）

经过思考，该题和上一个题有所区别，该题更多的是求“能到达的地方”，而不是一条具体的路线（就像洪水一样，计算的是洪水能够到达的地方，而不是洪水的哪股水流以怎样的具体路线碰到了一颗石头），因此和上一题的DFS不同，此题目用广度优先搜索BFS。经过调整，代码写法上简洁了许多，搜索策略和变量设置为：

搜索策略： 从起点开始，如果当前坐标满足阈值条件，则向四个方向都搜索一步（超过区域边界或已经搜索到的位置除外），不断“扩散”。

变量设置： 使用队列保存当前搜索过的位置信息，每次循环获取队首，它向四个方向搜索到的位置从队尾进入队列，最后队首元素出队，随着不断处理，队列为空时搜索完成。另一方面，由于四个方向都要搜索，于是不需要flag数组区分方向，只需要visited数组标记是否搜索过即可。

每个位置只会搜索一次，于是时间复杂度为O(mn)，通过了所有用例。

bool isAccessable(int cur_row, int cur_col, int rows, int cols, int threshold) { // 计算位置数位和，判断指定位置是否可以进入
    int sum = 0;
    int temp_row = cur_row;
    int temp_col = cur_col;

    while(temp_row){ // 计算坐标的数位之和
        sum += temp_row % 10;
        temp_row /= 10;
    }
    while(temp_col){
        sum += temp_col % 10;
        temp_col /= 10;
    }
    if(sum > threshold){
        return false;
    }

    return true;
}

int movingCount(int threshold, int rows, int cols) {
    int ans = 0;
    queue<int> path_rows;
    queue<int> path_cols;
    vector<vector<int> > visited;

    path_rows.push(0); // 初始化
    path_cols.push(0);
    vector<int> tempArr(cols, 0);
    for(int i=0; i<rows; i++){
        visited.push_back(tempArr);
    }
    visited[0][0] = 1;
    while(!path_rows.empty()){ // 开始搜索
        int cur_row = path_rows.front();
        int cur_col = path_cols.front();
        if(isAccessable(cur_row, cur_col, rows, cols, threshold)){
            if(cur_col-1 >= 0 && visited[cur_row][cur_col-1]==0){ //向左
                path_rows.push(cur_row);
                path_cols.push(cur_col-1);
                visited[cur_row][cur_col-1] = 1;
            }
            if(cur_row-1 >= 0 && visited[cur_row-1][cur_col]==0){ //向上
                path_rows.push(cur_row-1);
                path_cols.push(cur_col);
                visited[cur_row-1][cur_col] = 1;
            }
            if(cur_col+1 < cols && visited[cur_row][cur_col+1]==0){ //向右
                path_rows.push(cur_row);
                path_cols.push(cur_col+1);
                visited[cur_row][cur_col+1] = 1;
            }
            if(cur_row+1 < rows && visited[cur_row+1][cur_col]==0){ //向下
                path_rows.push(cur_row+1);
                path_cols.push(cur_col);
                visited[cur_row+1][cur_col] = 1;
            }
        }
        else{
            visited[cur_row][cur_col] = 0;
        }
        path_rows.pop();
        path_cols.pop();
    }
    for(int i=0; i<rows; i++){
        for(int j=0; j<cols; j++){
            if(visited[i][j] == 1){
                ++ans;
            }
        }
    }

    return ans;
}

Part3. 其他做法

书上的做法

思路相似，本质上也是BFS，但代码为递归写法，更加简洁。递归函数返回值为从某个位置开始能到达位置的数量，计算返回值时，对左、上、右、下位置均递归调用函数，将四次递归调用的结果相加，再加1（当前位置也是一个可以到达的位置）。

Part4. 心得体会

  • 这道题标注的是“困难”难度，但做出这道题的时间比上一道少一些，更加体会到难易是相对的。
  • 遇到和自己以前做过的相似的题目，要注意有什么不同，照搬原有思路可能并不是最优的选择。
二进制琴师
关注
专栏目录
python-剑指offer第66题机器人的运动范围
08-07
python python_剑指offer第66题机器人的运动范围
LLancelot#LeetCode#剑指 Offer 13. 机器人的运动范围1
07-25
示例 1：输出：3示例 2：输出：1提示：链接：
剑指offer_13_机器人的运动范围
cpyy103的博客
07-04 237
机器人的运动范围 描述 中等 地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？ 示例 1： 输入：m = 2, n = 3, k = 1 输出：3 示
[剑指Offer] 13_机器人的运动范围
热辣芒果园
12-24 105
题目 地上有一个m行n列的方格。一个机器人从坐标(0,0)的格子开始移动，他每次可以向左、右、上、下移动一格，但不能进入行坐标和列坐标的数位之和大于k的格子。请问该机器人能够到达多少个格子? 例: 当k为18时，机器人能够进入(35, 37)，因为3+5+3+7=18。但它不能进入放个(35, 38)， 因为3+5+3+8=19。 思路 回溯法。和题12同样进入一格后递归处理向其上下左右移动的...
剑指OFFER笔记_13_机器人的运动范围_JAVA实现
YesPlease的博客
06-11 252
剑指OFFER笔记_13_机器人的运动范围_JAVA实现题目：机器人的运动范围解题思路代码函数主体部分代码测试部分代码运行结果截图LeetCode运行截图 题目：机器人的运动范围 地上有一个m行n列的方格。一个机器人从坐标（0,0）的格子开始移动，它每次可以向左、右、上、下移动一格，但不能进入行坐标和列坐标的数位之和大于k的格子。请问该机器人能够到达多少个格子？ 解题思路 此题与前一题类似，采用回溯法。 对（0,0）时的情况开始调用函数计算count，当此处的条件符合时，依次递归调用row±1和col
剑指Offer - 13_机器人的运动范围
芝諾de乌龟
07-27 85
题目描述 地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？ 示例 输入：m = 2, n = 3, k = 1 输出：3 思路 深度优先搜索（DF
剑指Offer_13_机器人的运动范围
qitong啊的博客
07-19 118
package 二刷 /** * https://leetcode-cn.com/problems/ji-qi-ren-de-yun-dong-fan-wei-lcof/ * * @author Qitong!! * @Date 2020/6/30 */ public class 剑指Offer_13_机器人的运动范围 { private int m; private int n; private int k; private int count; pri
剑指Offer13_机器人的运动范围
qitong啊的博客
07-24 563
public class 剑指Offer_13_机器人的运动范围 { private int m; private int n; private int k; private int count; private boolean[][] mark; private int[][] matrix; public int movingCount(int m, int n, int k) { this.m = m; thi.
剑指offer____机器人的运动范围
ox0080的博客
11-16 138
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？   class Solution { public...
剑指 Offer 13. 机器人的运动范围
庄小焱
03-02 307
摘要摘要JZ13 机器人的运动范围（地上有一个 rows 行和 cols 列的方格。坐标从 [0,0] 到 [rows-1,cols-1]。一个机器人从坐标 [0,0] 的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 threshold 的格子。例如，当 threshold 为 18 时，机器人能够进入方格 [35,37] ，因为 3+5+3+7 = 18。但是，它不能进入方格 [35,38] ，因为 3+5+3+8 = 19。
剑指 Offer 13 -- 机器人的运动范围
xu_jin_shan的博客
03-24 159
剑指 Offer 13 – 机器人的运动范围 题目： 地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？ 示例 1： 输入：m = 2, n = 3, k
【剑指 Offer】13. 机器人的运动范围
qq_44653420的博客
05-30 153
剑指 Offer 13. 机器人的运动范围 题目 地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？ 思路   本题使用广度优先搜索的方法进行解题，这里需
Python《剑指offer》算法实现-机器人的运动范围
12-25
# Python实现《剑指offer》 部分代码自己添加了一些测试用例, 或者自己添加了一些功能 1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,...
《剑指Offer》刷题笔记——面试题13. 机器人的运动范围
01-21
1、剑指解析： 2、测试用例： 3、代码实现 I、回溯法 class Solution: def movingCount(self, m: int, n: int, k: int) -> int: self.discoveryed_plots = [] matrix = [[*] * n] * m self.discovery(matrix, ...
打造高效实时数仓，从Hive到OceanBase的经验分享
OceanBase分布式数据库的博客
09-12 893
鉴于初期采用的数据仓库方案面临高延迟、低效率等挑战，我们踏上了探索新数仓解决方案的征途。本文分享了我们从Hive到OceanBase的方案筛选与实施过程中的经验总结，期望能为您提供有价值的参考与启示。
C++学习笔记----6、内存管理（五）---- 智能指针（3）
weixin_71738303的博客
09-11 1179
与指向特定类型的原始指针可以转化为不同类型的指针一样，shared_ptr保存特定的类型可以转化为一个另一种类型的shared_ptr。转化shared_ptr的函数是const_pointer_cast()，dynamic_pointer_cast(),static_pointer_cast()和reinterpret_pointer_cast()。前面简要提过，当拥有共享属主的智能指针，例如shared_ptr不在活动范围或者被重置时，只有它是最后指向的智能指针时才能释放其指向的资源。
shader 案例学习笔记之将坐标系分成4个象限
localhost
09-13 210
坐标系被分成了4个单元格，每个单元格都有唯一的索引，后续就可以根据索引去渲染。
ROS组合导航笔记：融合传感器数据
最新发布
qq_44188415的博客
09-16 543
笔记
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 849
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
剑指Offer：算法题解与代码
"剑指offer.md" 这篇资源是关于《剑指Offer》这本书中的算法题目的编程实现，主要语言是C++，涉及的标签包括算法和C++。作者使用Markdown格式编写了文档，使得排版清晰，便于阅读。文件中包含的具体题目有二维数组...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值