1. 题目
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/98a40ec3bdb8541b14a6faaa2e0f1ad2.png#pic_center)
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;
}
}