剑指 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 = 1
输出:3


题解:
可以使用深度优先或者广度优先算法

1.深度优先搜索

可以理解为暴力法模拟机器人在矩阵中的所有路径。

DFS 通过递归,先朝一个方向搜到底,再回溯至上个节点,沿另一个方向搜索,以此类推。
剪枝: 在搜索中,遇到数位和超出目标值、此元素已访问,则应立即返回,称之为 可行性剪枝 。

算法解析:

递归参数:

  当前元素在矩阵中的行列索引 i 和 j ,两者的数位和 si, sj 。
终止条件:

  • ① 行列索引越界 
  • ② 数位和超出目标值 k 
  • ③ 当前元素已访问过 时,返回 0 ,代表不计入可达解。

递推工作:
  标记当前单元格 :将索引 (i, j) 存入 Set visited 中,代表此单元格已被访问过。
  搜索下一单元格: 计算当前元素的 下、右 两个方向元素的数位和,并开启下层递归 。
  回溯返回值: 返回 1 + 右方搜索的可达解总数 + 下方搜索的可达解总数,代表从本单元格递归搜索的可达解总数。

public class offer13 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int m =16,n=8;
        int k = 4;
        
        System.out.println(movingCount(m,n,k));
    }
    
    public static int movingCount(int m, int n,int k){
        boolean[][] visited = new boolean[m][n];
        int ans = dfs(0,0,m,n,k,visited);
        return ans;
        
    }
    //深度优先实现
    public static int dfs(int i,int j,int m,int n,int k,boolean[][] visited){
        if(i<0||i>=m||j<0||j>=n||bitSum(i)+bitSum(j)>k||visited[i][j]==true){//i,j索引超出边界或者数位之和大于k,或者已经访问过了,则返回0,代表不计入可达解
            return 0;
        }
        visited[i][j] = true;
        return 1 + 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) ;
    }
    
    //数位之和
    public static int bitSum(int i){
        int sum = 0;
        do{
            sum+=i%10;
            i = i/10;
        }while(i!=0);
        return sum;
    }
}

 2.广度优先搜索

BFS/DFS : 两者目标都是遍历整个矩阵,不同点在于搜索顺序不同。DFS 是朝一个方向走到底,再回退,以此类推;BFS 则是按照“平推”的方式向前搜索。
BFS 实现: 通常利用队列实现广度优先遍历。

算法解析:
  初始化: 将机器人初始点 (0, 0) 加入队列 queue ;
  迭代终止条件: queue 为空。代表已遍历完所有可达解。
  迭代工作:
    单元格出队: 将队首单元格的 索引 弹出,作为当前搜索单元格。
    判断是否跳过:

       ① 行列索引越界 

       ② 数位和超出目标值 k 

       ③ 当前元素已访问过 时,执行 continue 。
    标记当前单元格 :将单元格索引 (i, j) 存入 Set visited 中,代表此单元格 已被访问过 。
    单元格入队: 将当前元素的 下方、右方 单元格的 索引加入 queue 。
  返回值: Set visited 的长度 len(visited) ,即可达解的数量。

    public static int bfs(int m,int n,int k){
        boolean[][] visited = new boolean[m][n];
        int res = 0;
        Queue<int[]> queue = new LinkedList<int[]>();
        queue.add(new int[]{0,0});
        while(queue.size()>0){
            int[] x = queue.poll();
            int i = x[0],j = x[1];
            if(i>=m||j>=n||bitSum(i)+bitSum(j)>k||visited[i][j]==true){
                continue;
            }
            visited[i][j] = true;
            res++;
            queue.add(new int[]{i+1,j});
            queue.add(new int[]{i,j+1});
        }
        return res;
    }
参考题解
原文地址:https://www.cnblogs.com/Vincent-yuan/p/15063834.html