JZ66 剑指offer 机器人的运动范围

第66题 机器人的运动范围

题目描述

地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

class Solution {
public:
    int dir[5] = {-1, 0, 1, 0, -1};
    int getsum(int n){
        int sum = 0;
        while(n){
            sum += n % 10;
            n /= 10;
        }
        return sum;
    }
    void dfs(vector<vector<bool>>& visited,int tho, int i,int j,int rows,int cols,int& ret){
        if(i<0 || i>=rows || j < 0 || j>=cols || visited[i][j] || (getsum(i)+getsum(j)>tho)){
            return;
        }
        ret += 1;
        visited[i][j] = true;
        for (int a = 0; a < 4; ++a) {
            dfs(visited,tho,i + dir[a], j + dir[a + 1],rows,cols,ret);
        }
    }
    int movingCount(int threshold, int rows, int cols) {
        if(threshold<=0) return 0;
        
        vector<vector<bool>> visited(rows, vector<bool>(cols,false));
        int ret = 0;
        dfs(visited,threshold,0,0,rows,cols,ret);
        
        return ret;
    }
};

class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        
        def getsum(v):
            res = 0
            while v:
                res += v % 10
                v //= 10
            return res
        visited = [[False]*n for _ in range(m)]
        dire = [0,1,0]
        def dfs(i,j):
            nonlocal ret
            if not 0<=i<m or not 0 <= j <n or visited[i][j] or (getsum(i)+getsum(j)>k):
                return
            visited[i][j] = True
            ret += 1
            for e in range(2):
                dfs(i+dire[e], j+dire[e+1])
            return
        ret = 0
        dfs(0,0)
        return ret

思路：
深度优先搜索，从0，0处开始，visited保存是否遍历，超界或超值直接返回，否则ret+=1，访问记为true，再往四个方向进行搜索。

广度优先搜索版本：

class Solution {
public:
    using pii = pair<int,int>;
    int dir[5] = {-1, 0, 1, 0, -1};
    int getsum(int n){
        int sum = 0;
        while(n){
            sum += n % 10;
            n /= 10;
        }
        return sum;
    }

    int movingCount(int threshold, int rows, int cols) {
        if(threshold<=0) return 0;
        
        vector<vector<bool>> visited(rows, vector<bool>(cols,false));
        int ret = 0;
        queue<pii> q;
        q.push({0,0});
        visited[0][0] = true;
        
        while(!q.empty()){
            pii node = q.front();
            q.pop();
            ++ret;
            for(int i =0;i < 4; ++i){
                int x = node.first + dir[i];
                int y = node.second + dir[i+1];
                if(x >= 0 && x < rows && y >= 0 && y < cols && !visited[x][y] && (getsum(x)+getsum(y)<=threshold)){
                    q.push({x,y});
                    visited[x][y] = true;
                }
            }
        }
        return ret;
    }
};

class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        
        def getsum(v):
            res = 0
            while v:
                res += v % 10
                v //= 10
            return res
        visited = [[False]*n for _ in range(m)]
        dire = [0,1,0]
        ret = 0
        q = collections.deque()
        q.append((0,0))
        visited[0][0]=True
        while q:
            i, j = q.popleft()
            ret += 1
            for e in range(2):
                x, y = i + dire[e], j + dire[e+1]
                if 0<=x<m and 0<=y<n and not visited[x][y] and (getsum(x)+getsum(y)<=k):
                    visited[x][y] = True
                    q.append((x,y))

        return ret

借助坐标队列，每次出队列时，四个方向进行遍历，把满足条件的坐标入队列。