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

难度：中等。

开始理解错了！没想到机器人是沿着格子走的，有的格子虽然位数和小于k，但是不能从[0,0]到达，因为中间被隔断了。

刚开始写的代码是计算了矩阵中，所有位数和小于k的格子数。
错误代码：

class Solution {
public:
    int movingCount(int m, int n, int k) {
        int res = 0;
        int u = (m - 1) % 10 + 10;
        vector<int> arr(u, -1);
        for(int i = 0; i < m; i++){
            int i_sum = i / 10 + i % 10;
            if(i_sum > k)continue;
            int j_sum = k - i_sum;
            if(arr[i_sum] != -1){
                res += arr[i_sum];
                continue;
            }
            int temp_res = 0;
            for(int j = 0; j <= (n - 1) / 10; j++){
                if(j > j_sum)continue;
                int x = min(j_sum - j, 9);
                int y = x + 1;
                if(j == (n - 1) / 10)y = min(x + 1, (n - 1) % 10 + 1);
                temp_res += y;
            }
            arr[i_sum] = temp_res;
            res += temp_res;
        }
        return res;
    }
};

使用广度优先搜索来完成这个题。

正确解法：

class Solution {

    int get(int x){
        int res = 0;
        while(x){
            res += x % 10;
            x /= 10;
        }
        return res;
    }

public:
    int movingCount(int m, int n, int k) {
        queue<pair<int, int>> que;
        vector<vector<int>> path(m, vector<int>(n));
        que.push(make_pair(0, 0));
        path[0][0] = 1;
        int res = 1;
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; ++i){
                pair p = que.front();
                que.pop();
                
                int sum2 = get(p.first) + get(p.second + 1);
                if(p.first < m - 1){
                    int sum = get(p.first + 1) + get(p.second);
                    if(sum <= k && path[p.first + 1][p.second] == 0){
                        que.push(make_pair(p.first + 1, p.second));
                        path[p.first + 1][p.second] = 1;
                        res++;
                    }
                }
                if(p.second < n - 1){
                    int sum = get(p.first) + get(p.second + 1);
                    if(sum <= k && path[p.first][p.second + 1] == 0){
                        que.push(make_pair(p.first, p.second + 1));
                        path[p.first][p.second + 1] = 1;
                        res++;
                    }
                }

            }
        }
        
        return res;
    }
};

结果：

也可以使用动态规划的方法来做，具体思路见代码。

正确解法：

class Solution {

    int get(int x){
        int res = 0;
        while(x){
            res += x % 10;
            x /= 10;
        }
        return res;
    }

public:
    int movingCount(int m, int n, int k) {
        if(k == 0)return 1;
        vector<vector<int>> dp(m, vector<int>(n));
        dp[0][0] = 1;
        int res = 1;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(i == 0 && j == 0)continue;
                if(get(i) + get(j) <= k){
                    if(i == 0)dp[i][j] = dp[i][j - 1];
                    else if(j == 0)dp[i][j] = dp[i - 1][j];
                    else dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
                }
                res += dp[i][j];
            }   
        }
        return res;
    }
};

结果：