关于dfs什么时候需要使用回溯，什么时候不需要使用回溯：
dfs常见题目，全排列、八皇后、红与黑：
DFS连通性模型： 又可以分为需要回溯和不需要回溯：
eg1.红与黑
有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。
你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。
请写一个程序，计算你总共能够到达多少块黑色的瓷砖。
输入格式
输入包括多个数据集合。
每个数据集合的第一行是两个整数 W和 H，分别表示 x 方向和 y方向瓷砖的数量。
在接下来的 H 行中，每行包括 W个字符。每个字符表示一块瓷砖的颜色，规则如下
1）‘.’：黑色的瓷砖；
2）‘#’：红色的瓷砖；
3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。
当在一行中读入的是两个零时，表示输入结束。
输出格式
对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。
数据范围
1≤W,H≤20
输入样例：
6 9
....#.
.....#
......
......
......
......
......
#@...#
.#..#.
0 0
输出样例：
45
思路：需要找出所有从初始点能够到达的点，所以被搜的点直接标记，然后继续递归搜索其他点即可，直到无法搜索到合法的点即可。最后返回结果就行。
public class Main {
static int w, h;
static int cnt;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
char[][] graph = new char[25][25];
cnt = 0;
h = sc.nextInt();
w = sc.nextInt();
if (w == 0 && h == 0) {
return;
}
int st = 0, ed = 0;
for (int i = 0; i < w; i++) {
String str;
str = sc.next();
for (int j = 0; j < h; j++) {
graph[i][j] = str.charAt(j);
if (graph[i][j] == '@') {
st = i;
ed = j;
}
}
}
dfs(graph, st, ed);
System.out.println(cnt);
}
}
public static void dfs(char[][] g, int x, int y) {
int[] dx = {0, -1, 0, 1};
int[] dy = {-1, 0, 1, 0};
if (g[x][y] == '#') {
return ;
}
cnt++;
g[x][y] = '#';
for (int i = 0; i < 4; i++) {
int a = x + dx[i];
int b = y + dy[i];
if (a >= 0 && a < w && b >= 0 && b < h && g[a][b] == '.') {
dfs(g, a, b);
}
}
}
}
eg2.八皇后，马走日
经典dfs+回溯
马在中国象棋以日字形规则移动。
请编写一段程序，给定 n∗m大小的棋盘，以及马的初始位置 (x，y)，要求不能重复经过棋盘上的同一个点，计算马可以有多少途径遍历棋盘上的所有点。
输入格式
第一行为整数 T，表示测试数据组数。
每一组测试数据包含一行，为四个整数，分别为棋盘的大小以及初始位置坐标 n,m,x,y。
输出格式
每组测试数据包含一行，为一个整数，表示马能遍历棋盘的途径总数，若无法遍历棋盘上的所有点则输出 0。
数据范围
1≤T≤9,
1≤m,n≤9,
1≤n×m≤28,
0≤x≤n−1,
0≤y≤m−1，
输入样例：
1
5 4 0 0
输出样例：
32
dfs，可以在图上画出棋子可走的八个方向，然后采用dfs
public class Main {
static int T;
static int cnt;
static int res;
static int n,m;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
T = sc.nextInt();
for (int i = 0; i < T; i++) {
int[][] g;//记录是否访问过该点，访问为1，未访问为0
res = 0;
n = sc.nextInt();
m = sc.nextInt();
g = new int[n+1][m+1];
int x,y;
x = sc.nextInt();
y = sc.nextInt();
g[x][y] = 1;
dfs(g,x,y,1);
System.out.println(res);
}
}
public static void dfs(int[][] g,int x,int y,int t){
int[] dx = {-1,-2,-2,-1,1,2,2,1};
int[] dy = {-2,-1,1,2,2,1,-1,-2};
if(t == n * m){//当访问的点数为棋盘上所有的点时，表明符合，所以路线+1,
res++;
return;
}
for(int i = 0; i < 8; i++){
int a = x + dx[i];
int b = y + dy[i];
if(a >= 0 && a < n && b >= 0 && b < m && g[a][b] == 0){
g[a][b] = 1;
dfs(g,a,b,t+1);
g[a][b] = 0;//回溯
}
}
}
}
迷宫类问题，测试两点之间是否连通需要使用回溯。因为当前路径不一定能够到达目标，搜索到非法路径时就需要恢复现场。
