1. 深度优先搜索(DFS)

深度优先遍历主要思路是从图中一个未访问的顶点 V 开始，沿着一条路一直走到底，然后从这条路尽头的节点回退到上一个节点，再从另一条路开始走到底…，不断递归重复此过程，直到所有的顶点都遍历完成。

例题 P1605 迷宫

题目描述

给定一个 $N\times M$ 方格的迷宫，迷宫里有 $T$ 处障碍，障碍处不可通过。

在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。

给定起点坐标和终点坐标，每个方格最多经过一次，问有多少种从起点坐标到终点坐标的方案。

输入格式

第一行为三个正整数 $N,M,T$，分别表示迷宫的长宽和障碍总数。

第二行为四个正整数 $SX,SY,FX,FY$，$SX,SY$ 代表起点坐标，$FX,FY$ 代表终点坐标。

接下来 $T$ 行，每行两个正整数，表示障碍点的坐标。

输出格式

输出从起点坐标到终点坐标的方案总数。

样例输入 #1

2 2 1
1 1 2 2
1 2

样例输出 #1

1

提示

对于 $100\%$ 的数据，$1\le N,M\le 5$，$1\le T\le 10$，$1\le SX,FX\le n$，$1\le SY,FY\le m$。

思路

使用深搜遍历图，成功搜到则方案数加1，否则回溯继续下一条路径的搜索，直到所有的都遍历过了结束

代码

#include <bits/stdc++.h>
using namespace std;
const int Max=10;
int mapp[Max][Max]={0};
int N,M;
int T;  //障碍数
int ans=0;  //方案数
int sx,sy,fx,fy; //（sx,sy)——>(fx,fy)
int visited[Max][Max]={0};
int nextx[4]={-1,0,1,0};
int nexty[4]={0,1,0,-1};
void dfs(int x, int y){
   // printf("(%d,%d)",x,y);
    if(x==fx && y==fy){
        ans++;
        return;
    }
    //if(x>N-1 || y>M-1)  return ;
    int next_x,next_y;
    for(int i=0; i < 4; i++){
        next_x=x+nextx[i];
        next_y=y+nexty[i];
        if(next_x > 0 && next_x<= N && next_y > 0 && next_y<= M && visited[next_x][next_y]==0 && mapp[next_x][next_y]==0){
            visited[next_x][next_y]=1;
            dfs(next_x, next_y);
            visited[next_x][next_y]=0;
        }
    }
}
int main(){
    cin >> N >> M >> T;
    cin >> sx >> sy >> fx >> fy;
    for(int i = 0; i < T; i++){
        int x,y;
        cin >> x >> y;
        mapp[x][y]=1;
    }
    visited[sx][sy]=1;
    dfs(sx,sy);
    cout << ans << endl;
}

2. 广度优先搜索(BFS)

广度优先搜索从初始结点开始，遍历生成第一层结点，同时检查目标结点是否在这些生成的结点中；若没有，再将所有第一层结点逐一拓展，得到第二层结点,，逐一检査第二层结点是否包含目标结点；若没有,再拓展第二层结点… 如此依次拓展、检査下去，直至发现目标结点为止。如果拓展完所有结点都没有发现目标结点，则问题无解。
使用广度优先遍历，自我感觉与按层遍历有些相似
用到队列，不递归

例题 P1443 马的遍历

题目描述

有一个 $n\times m$ 的棋盘，在某个点 $(x,y)$ 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。

输入格式

输入只有一行四个整数，分别为 $n,m,x,y$。

输出格式

一个 $n\times m$ 的矩阵，代表马到达某个点最少要走几步（不能到达则输出 $-1$）。

样例输入 #1

3 3 1 1

样例输出 #1

0    3    2    
3    -1   1    
2    1    4

数据规模与约定

对于全部的测试点，保证 $1\le x\le n\le 400$，$1\le y\le m\le 400$。

思路

因为要看最少走几步可以到达某个点，就是看这个点在第几层上，在第几层最小步数就是几。
那么怎么求层数？ num++ 就好喽
问题在于num什么时候++，就是说每一层有几个，这一层都出队列了，num这时候就加一
那么就需要统计每一层的个数：成功入队我们就记录一次。

代码

#include <bits/stdc++.h>
using namespace std;
const int Max=405;
int n,m,x,y;
int qipan[Max][Max];
int nextx[8]={1,2,2,1,-1,-2,-2,-1};
int nexty[8]={2,1,-1,-2,-2,-1,1,2};
int num=0;  //最小步数
queue<pair<int, int> > q;
void bfs(int x, int y){
    q.push(make_pair(x,y));
    qipan[x][y]=0;
    int tongceng=1;  //同一层上有几个点
    while(!q.empty()){
        
        num++;
        int tongceng1=0;  //记录同层上的个数
        for(int j = 0; j<tongceng; j++){
            int nx= q.front().first;
            int ny= q.front().second;
            q.pop();
            for(int i=0; i< 8; i++){
                int next_x=nx+nextx[i];
                int next_y=ny+nexty[i];
                if(next_x >0 && next_x <= n && next_y > 0 && next_y <= m && qipan[next_x][next_y]==-1){
                    q.push(make_pair(next_x, next_y));
                    qipan[next_x][next_y]=num;
                    tongceng1++;
                }
            }
        }
        tongceng=tongceng1;

    }
}

void print(){
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            if(qipan[i][j]== -1)
                cout << setw(5) << left << qipan[i][j] << " ";
            else
                cout << setw(5) << left << qipan[i][j] << " ";
        }
        cout << endl;
    }
}
int main(){
    cin >> n >> m >> x >> y;
    
    memset(qipan,-1,sizeof(qipan));
    //cout << qipan[3][3];
    bfs(x,y);
    print();
}

注意：马走“日”，我忘喽~~~