2021.10.10 - JZ13.机器人的运动范围

1. 题目

2. 思路

(1) BFS

• 利用队列实现广度优先搜索，由于已经确定是从(0,0)向(m-1,n-1)进行搜索，因此可以省略i-1或j-1方向的搜索。
• 注意！将一个位置加入队列后就要设置该位置为已访问，避免重复访问。

(2) DFS

• 利用递归实现深度优先搜索，首先确定该位置是否可以到达，然后设置该位置为已访问，最后对i+1和j+1方向进行递归搜索。

3. 代码

import java.util.LinkedList;
import java.util.Queue;

public class Test {
    public static void main(String[] args) {
    }
}

class Solution {
    public int movingCount(int m, int n, int k) {
        if (k == 0) {
            return 1;
        }
        boolean[][] flag = new boolean[m][n];
        int res = 0;
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{0, 0});
        flag[0][0] = true;
        res++;
        while (!queue.isEmpty()) {
            int[] index = queue.poll();
            int i = index[0];
            int j = index[1];
            if (i + 1 < m && !flag[i + 1][j] && sum(i + 1, j) <= k) {
                queue.offer(new int[]{i + 1, j});
                flag[i + 1][j] = true;
                res++;
            }
            if (j + 1 < n && !flag[i][j + 1] && sum(i, j + 1) <= k) {
                queue.offer(new int[]{i, j + 1});
                flag[i][j + 1] = true;
                res++;
            }
        }
        return res;
    }

    private int sum(int i, int j) {
        int res = 0;
        while (i > 0) {
            res += (i % 10);
            i /= 10;
        }
        while (j > 0) {
            res += (j % 10);
            j /= 10;
        }
        return res;
    }
}

class Solution1 {
    private int m;
    private int n;
    private int k;
    private boolean[][] flag;

    public int movingCount(int m, int n, int k) {
        if (k == 0) {
            return 1;
        }
        this.m = m;
        this.n = n;
        this.k = k;
        flag = new boolean[m][n];
        return dfs(0, 0, sum(0, 0));
    }

    private int dfs(int i, int j, int sum) {
        if (i >= m || j >= n | sum > k || flag[i][j]) {
            return 0;
        }
        flag[i][j] = true;
        return dfs(i + 1, j, sum(i + 1, j)) + dfs(i, j + 1, sum(i, j + 1)) + 1;
    }

    private int sum(int i, int j) {
        int res = 0;
        while (i > 0) {
            res += (i % 10);
            i /= 10;
        }
        while (j > 0) {
            res += (j % 10);
            j /= 10;
        }
        return res;
    }
}