深度优先搜索

深度优先搜索本质就是递归，类似于树的前序遍历，尽可能对纵深方向进行搜索，从源点开始，依次访问未被访问的点，直到找到终点：
（1）选择源点；
（2）访问未被访问的邻接点，如果没有可以访问的点，则向上回溯，直到找到可以访问的点；如果所有点均被访问过，则没有找到终点，失败；
（3）将所有访问过的点Book= 1,表示已经访问过；

迷宫问题迷宫由n行m列的单元格组成（n,m都小于等于50），每个单元格要么是空地，要么是障碍物。先请你找一条从起点到终点的最短路径。

回溯

1. #include <iostream>  
2. #include <bits/stdc++.h>  
3. using namespace std;  
4. int p, q, m, n, minn = 0x3f3f3f3f;  
5. int a[100][100];    //0表示空地，1表示障碍物；  
6. int book[100][100]; //0表示未访问，1表示访问；  
7. int dx[4] = {0, 1, 0, -1};  
8. int dy[4] = {1, 0, -1, 0}; //方向数组右下左上；  
9.   
10. void dfs(int x, int y, int step)  
11. {  
12.     int tx, ty, k;  
13.     if (x == p && y == q)  
14.     {  
15.         if (step < minn)  
16.             minn = step;  
17.         return; //  
18.     }  
19.   
20.     for (int k = 0; k <= 3; k++)  
21.     { //遍历各个方向；  
22.         tx = x + dx[k];  
23.         ty = y + dy[k];  
24.         if (tx < 1 || tx > n || ty < 1 || ty > m)  
25.         { //判断是否越界，越界则不处理；  
26.             continue;  
27.         }  
28.         if (a[tx][ty] == 0 && book[tx][ty] == 0)  
29.         {  
30.             book[tx][ty] = 1;  
31.             dfs(tx, ty, step + 1);  
32.             book[tx][ty] = 0;  
33.         }  
34.     }  
35.     return;  
36. }  
37. int main()  
38. {  
39.     int i, j, startx, starty;  
40.     cin >> n >> m;  
41.     for (i = 1; i <= n; i++)  
42.     {  
43.         for (int j = 1; j <= m; j++)  
44.         {  
45.             cin >> a[i][j];  
46.         }  
47.     }  
48.     cin >> startx >> starty >> p >> q;  
49.     book[startx][starty] = 1;  
50.     dfs(startx, starty, 0);  
51.     cout << minn;  
52.     getchar();  
53.     getchar();  
54.     return 0;  
55. }  
56. /* 
57. 5 4  
58. 0 0 1 0 
59. 0 0 0 0 
60. 0 0 1 0  
61. 0 1 0 0 
62. 0 0 0 1 
63. 1 1 4 3 
64. */  

对于方向的处理有多种方法:方法一：挨个循环遍历：

1. //顺时针探索  
2.    // 右  
3.    if(a[x][y+1]==0 && book[x][y+1]==0){  
4.        book[x][y+1] = 1;  
5.        dfs(x,y+1,step+1);  
6.        book[x][y+1]=0;  
7.    }  
8.    //下  
9.    if(a[x+1][y]==0 && book[x+1][y]==0){  
10.        book[x+1][y] = 1;  
11.        dfs(x+1,y,step+1);  
12.        book[x+1][y]=0;  
13.    }  
14.    //左  
15.    if(a[x][y-1]==0 && book[x][y-1]==0){  
16.        book[x][y-1] = 1;  
17.        dfs(x,y-1,step+1);  
18.        book[x][y-1]=0;  
19.    }  
20.    //上  
21.    if(a[x-1][y]==0 && book[x-1][y]==0){  
22.        book[x-1][y] = 1;  
23.        dfs(x-1,y,step+1);  
24.        book[x-1][y]=0;  
25.    }  

一维方向数组⭐

1. int dx[4] = {0, 1, 0, -1};  
2. int dy[4] = {1, 0, -1, 0};  
3. for (int k = 0; k <= 3; k++)  
4.     { //遍历各个方向；  
5.       
6.         tx = x + dx[k];  
7.         ty = y + dy[k];  
8. }  

二维方向数组

1.    //二维数组表示方向  
2.    int next[4][2]={{0,1},  
3.                    {1,0},  
4.                    {0,-1},  
5.                    {-1,0}};  
6.    for(int k = 0 ; k <= 3 ; k++){  
7.        tx = x +next[k][0];  
8.        ty= y+next[k][1];  
9.    }