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

机器人的运动范围

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

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.visited = []
        self.count = 0
        
    def dfs(self,threshold,rows,cols,i,j,direction):
        if i < 0 or i >= rows or j < 0 or j >= cols:
            return
        elif self.visited[i][j] == 1:
            return
        else:
            self.visited[i][j] = 1
            num = 0
            for n1 in str(i):
                num += int(n1)
            for n2 in str(j):
                num += int(n2)
            if num <= threshold:
                self.count += 1
                for direct in direction:
                    x = i+direct[0]
                    y = j+direct[1]
                    self.dfs(threshold,rows,cols,x,y,direction)
        
    def movingCount(self, threshold, rows, cols):
        self.visited = [[0 for c in range(cols)]for r in range(rows)]
        direction = [[0,1],[0,-1],[1,0],[-1,0]]
        self.dfs(threshold,rows,cols,0,0,direction)
        return self.count
        # write code here

 

补充java的实现：

class Solution {
    int[][] visited;
    int count = 0;

    private void dfs(int threashold, int rows, int cols, int i, int j, int[][] direction) {
        if (i < 0 || i >= rows || j < 0 || j >= cols) {
            return;
        } else if (this.visited[i][j] == 1) {
            return;
        } else {
            this.visited[i][j] = 1;

            int num = 0;
            String n1 = new Integer(i).toString();

            for (int x = 0; x < n1.length(); x++) {
                Character c = n1.charAt(x);
                num += Integer.parseInt(c.toString());
            }

            String n2 = new Integer(j).toString();

            for (int x = 0; x < n2.length(); x++) {
                Character c = n2.charAt(x);
                num += Integer.parseInt(c.toString());
            }

            if (num <= threashold) {
                this.count++;
                for (int[] direct : direction) {
                    int a = i + direct[0];
                    int b = j + direct[1];
                    this.dfs(threashold, rows, cols, a, b, direction);
                }
            }
        }
    }

    public int movingCount(int m, int n, int k) {
        this.visited = new int[m][n];
        int[][] direction = new int[][] { { 0, 1 }, { 0, -1 }, { 1, 0 }, { -1, 0 } };
        this.dfs(k, m, n, 0, 0, direction);
        return this.count;

    }
}