剑指 Offer 13. 机器人的运动范围

剑指 Offer 13. 机器人的运动范围

剑指 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

示例 2：
输入：m = 3, n = 1, k = 0
输出：1

提示：
1 <= n,m <= 100
0 <= k <= 20

---

思路1：暴力法

思路也简单，就是求得x,y的所有位数和，判断是否小于或等于k

class Solution {
    public int movingCount(int m, int n, int k) {
        //边界条件
        if(m < 0 || n < 0 || k < 0) return 0;
        int count = 0;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(change(i) + change(j) <= k){
                    count++;
                }
            }
        }
        return count;
    }

    public int change(int n){//n = 16
        int sum = n%10;//6
        while(n/10 != 0){// 1 != 0
            n = n/10;// n = 1       n = 1
            sum = sum + n%10;// sum = 6 + 1
        }
        return sum;
    }
}

结果，不符合要求
原因是，除了判断位数和是否小于或等于k之外，还有一个潜在的条件：
机器人能否到达此处
怎么理解这句话呢，看图：

LeetCode上大神给出的图，原图在这

// 如 let m = 20, n = 15, k = 9, 满足不大于k时的图, 红色区域不满足, 来张图可能会更好理解

// 再加上能走通的条件, 就是写个函数执行 每一块都 上下左右 走一下, 判断走过的就不走了 碰到边界也不走

两个条件，一个是否满足x + y <= k
一个条件是能否走到那

因此，暴力法宣布失败

---

那么，试试dp

思路2：dp

1. 是否为最大值问题？
   是，机器人能走的最大格子

2. 能否使用dp
   1 是否能将原问题转化为子问题
   可以
   2 是否无后效性
   无后效性

3. 如何使用dp
   1 确定dp含义
   dp[i][j] 第i行，第j列能否到达
   2 确定边界值
   dp[0][0] = true;
   dp[0][j] 只需要确定j的位数和 <= k即可
   dp[i][0] 只需要确定i的位数和 <=k 即可
   3 确定状态转移方程
   dp[i][j]能到达的条件：
   i的位数和 + i的位数和 <= k
   且
   dp[i][j - 1] == true 或者 dp[i - 1][j] == true

class Solution {
    public int movingCount(int m, int n, int k) {
        //边界条件
        if(m < 0 || n < 0 || k < 0) return 0;
        int count = 1;

        //建立dp二维数组
        boolean[][] dp = new boolean[m][n];
        dp[0][0] = true;
        for(int i = 1; i < m; i++){
            if(change(i) <= k && dp[i - 1][0]){
                dp[i][0] = true;
                count++;
            }
        }

        for(int j = 1; j < n; j++){
            if(change(j) <= k  && dp[0][j - 1]){
                dp[0][j] = true;
                count++;
            }
        }

        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                if(change(i) + change(j) <= k && (dp[i][j-1] || dp[i - 1][j])){
                    dp[i][j] = true;
                    count++;
                }
            }
        }
        return count;
    }

    public int change(int n){//n = 16
        int sum = n%10;//6
        while(n/10 != 0){// 1 != 0
            n = n/10;// n = 1       n = 1
            sum = sum + n%10;// sum = 6 + 1
        }
        return sum;
    }
}

经历过不断地提交失败

终于成功了

又想起那句话：

一杯茶，一包烟，一道算法解一天

---

深度优先、广度优先是弱项
回溯、剪枝弱项