广度优先搜索（BFS）：主要用于树的层序遍历或图的最短路径寻找，主要使用队列queue来完成。
//基本java 模板：
int level =0;
while (!deque.isEmpty()){
size = deque.size();
while(size-- >0){
cur = deque.poll();
foreach 节点 in cur所有的相邻节点:
if 该节点不为空且没有被访问过：
deque.offer(该节点)
}
level ++ ;
}深度优先搜索（DFS）：一直往深处走，直到找到解或者走不下去为止，主要用于树的遍历（前序遍历，中序遍历，后序遍历）或者图的搜索问题或者回溯算法问题。
参考：BFS和DFS总结
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。
[["a","b","c","e"],
["s","f","c","s"],
["a","d","e","e"]]
但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。
解题思路
遍历每一个字符，从该字符开始进行深度遍历。
如果超出边界或者递归过程中 当前字符不等于work[k] 就说明遇到不匹配 直接返回
如果 k==length-1 遍历完了，不符合上述条件就说明成功了
访问过就将当前路径置0，表示访问过。这样递归过程中 访问过的都会置0
递归过程中有一个返回的为真，就返回给上层递归。
返回递归后，恢复原来的字符。
代码 链接：https://leetcode-cn.com/problems/ju-zhen-zhong-de-lu-jing-lcof/solution/dfssou-suo-lu-jing-by-jian-57-lxae/
class Solution {
public boolean exist(char[][] board, String word) {
char[] words = word.toCharArray();
for (int i = 0; i < board.length; i++)
for (int j = 0; j < board[0].length; j++){
if (dfs(board, words, i, j, 0))
return true;
}
return false;
}
public boolean dfs(char[][] board, char[] word, int i, int j, int k) {
if (i >= board.length || i < 0 || j >= board[0].length || j < 0 || board[i][j] != word[k]) {
return false;
}
if (k == word.length - 1) return true;
char tmp = board[i][j];
board[i][j] = '\0';
boolean res = dfs(board, word, i + 1, j, k + 1) || dfs(board, word, i - 1, j, k + 1) ||
dfs(board, word, i, j + 1, k + 1) || dfs(board, word, i, j - 1, k + 1);
board[i][j] = tmp;
return res;
}
}地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？
class Solution {
public int movingCount(int m, int n, int k) {
boolean[][] visited =new boolean[m][n];
return dfs(0,0,m,n,k,visited);
}
public int dfs(int i,int j,int m, int n, int k,boolean[][] visit){
if(i<0||j<0||i>=m||j>=n||(i/10+j/10+i%10+j%10)>k||visit[i][j])
return 0;
visit[i][j] =true;
int res=dfs(i+1,j,m,n,k,visit) +dfs(i,j+1,m,n,k,visit)+dfs(i-1,j,m,n,k,visit)+dfs(i,j-1,m,n,k,visit)+1;
// visit[i][j]=false;
return res;
}
}class Solution {
int m,n,k;
boolean[][] visit;
public int movingCount(int m,int n,int k) {
this.visit= new boolean[m][n];
this.m=m;
this.n=n;
this.k=k;
return dfs(0,0);
}
public int dfs(int i,int j){
if(i<0||j<0||i>=m||j>=n||getSum(i,j)>k||visit[i][j])
return 0;
visit[i][j] =true;
int res=dfs(i+1,j) +dfs(i,j+1)+1;
//visit[i][j]=false;
return res;
}
private int getSum(int i,int j){
int sum =0;
while (i!=0){
sum += (i%10);
i /= 10;
}
while (j!=0){
sum += (j%10);
j /= 10;
}
return sum;
}
}//BFS 方式
class Solution {
public int movingCount(int m, int n, int k) {
boolean[][] visit =new boolean[m][n] ;
int res = 0;
Deque<int[]> queue =new ArrayDeque<>();
queue.offer(new int[]{0, 0});
while (!queue.isEmpty()) {
int[] tmp = queue.poll();
int i = tmp[0], j = tmp[1];
if ( i >= m || j >= n || getSum(i, j) > k || visit[i][j])
continue;
visit[i][j] = true;
res ++;
queue.offer(new int[]{i, j + 1});
queue.offer(new int[]{i + 1, j});
}
return res;
}
private int getSum(int i, int j) {
int sum = 0 ;
while (i != 0) {
sum += (i % 10);
i /= 10;
}
while (j != 0) {
sum += (j % 10);
j /= 10;
}
return sum;
}
}