Java教程

机器人的运动范围(剑指offer 13) Java深度优先遍历

本文主要是介绍机器人的运动范围(剑指offer 13) Java深度优先遍历,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

目录

一、题目描述

二、思路讲解

三、Java代码实现

四、时空复杂度分析

五、代码优化 

        1、不需要向上和向左搜索 

        2、 数位求和无需循环

        3、函数传值还可简化


 

一、题目描述

        地上有一个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


示例 2:

输入:m = 3, n = 1, k = 0
输出:1


提示:

1 <= n,m <= 100
0 <= k <= 20

二、思路讲解

        对于我这种算法小白来说,看见在矩阵中上下左右跑的,直接无脑深搜。

        从(0,0)开始,像上下左右方向分别找满足条件的节点,如果某一个方向满足条件,就走到这个位置,继续找这个位置的上下左右(递归);如果某一个方向不满足条件,应该排除掉这个方向(剪枝操作)。当四个方向都找完之后,回到上一个节点(回溯)。

为了避免走“回头路”,避免将已经访问过的节点再算上去,我们定义一个二位数组visited,来标记是否访问过。

然后是确定跳出递归的条件:

        1、超出边界;

        2、数位之和大于k;

        3、已经被访问过。

三、Java代码实现

class Solution {
    public int movingCount(int m, int n, int k) {
        //用来标记该位置是否访问过 为1则访问过
        int [][]visited = new int[m][n];

        return dfs(0, 0, m, n, k, 0, visited);
    }

    public static int dfs(int i, int j, int m, int n, int k, int count, int [][]visited) {
    	
        //如果指针越界 或 行列数位之和大于k 或 被访问过,则直接返回count次数
    	if(i<0 || j<0 || i>=m || j>=n || fun(i, j)>k || visited[i][j]==1) {
    		return count;
    	}
    	
        //将当前位置标记为已访问
    	visited[i][j] = 1;
        //满足条件的格子数+1
    	count++;
    	
    	count = dfs(i-1, j, m, n, k, count, visited); //往上找
    	count = dfs(i+1, j, m, n, k, count, visited); //往下找
    	count = dfs(i, j-1, m, n, k, count, visited); //往左找
    	count = dfs(i, j+1, m, n, k, count, visited); //往右找
    	
    	return count;
    }

    //用来计算坐标为(m,n)的数位之和
    public static int fun(int m, int n){
        int sum = 0;
        while(m!=0){
            sum = sum + m%10;
            m = m/10;
        }
        while(n!=0){
            sum = sum + n%10;
            n = n/10;
        }
        return sum;
    }
}

 

四、时空复杂度分析

        时间复杂度:        O(MN)        最坏情况下,机器人遍历整个矩阵

        空间复杂度:        O(MN)        最坏情况下,visited矩阵存储所有单元格的索引

五、代码优化 

        1、不需要向上和向左搜索 

        由于机器人从左上角出发,所以他只会往右或往下走,因此不需要向上和向左搜索。

        2、 数位求和无需循环

        由于题目中矩阵的坐标都是一位或者两位数,要想求这样数字的数位和只需要x%10 + x/10即可 。

        3、函数传值还可简化

        其实dfs中不需要把count传进去计算所有满足条件的格子数量,只需要返回这一支的满足条件的数量就行了。 

class Solution {
    public int movingCount(int m, int n, int k) {
        //用来标记该位置是否访问过 为1则访问过
        int [][]visited = new int[m][n];

        return dfs(0, 0, m, n, k, visited);
    }

    public static int dfs(int i, int j, int m, int n, int k, int [][]visited) {
    	
        //如果指针越界 或 行列数位之和大于k 或 被访问过,则直接返回count次数
    	if(i<0 || j<0 || i>=m || j>=n || fun(i, j)>k || visited[i][j]==1) {
    		return 0;
    	}
    	
        //将当前位置标记为已访问
    	visited[i][j] = 1;
        //         往下找                          往右找          	
    	return 1 + dfs(i+1, j, m, n, k, visited) + dfs(i, j+1, m, n, k, visited);
    }

    //用来计算坐标为(m,n)的数位之和
    public static int fun(int m, int n){
        return m%10 + m/10 + n%10 + n/10;
    }
}

这篇关于机器人的运动范围(剑指offer 13) Java深度优先遍历的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!