【基础算法】DFS

DFS

一条路走到黑

【模板】

void dfs()//参数用来表示状态  
{  
    if(到达终点状态)  
    {  
        ...//根据题意添加  
        return;  
    }  
    if(越界或者是不合法状态)  
        return;  
    if(特殊状态)//剪枝
        return ;
    for(扩展方式)  
    {  
        if(扩展方式所达到状态合法)  
        {  
            修改操作;//根据题意来添加  
            标记；  
            dfs（）；  
            (还原标记)；  
            //是否还原标记根据题意  
            //如果加上（还原标记）就是 回溯法  
        }  
 
    }  
}  

题目总结

0x01：迷宫

【题目】
一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由 n∗n 的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。
同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。
如果起点或者终点有一个不能通行(为#)，则看成无法办到。
注意：A、B不一定是两个不同的点。

【输入格式】
第1行是测试数据的组数 k ，后面跟着 k 组输入。
每组测试数据的第1行是一个正整数 n ，表示迷宫的规模是 n∗n 的。
接下来是一个 n∗n 的矩阵，矩阵中的元素为.或者#。
再接下来一行是 4 个整数 ha,la,hb,lb ，描述 A 处在第 ha 行, 第 la 列， B 处在第 hb 行, 第 lb 列。
注意到 ha,la,hb,lb 全部是从 0 开始计数的。
【输出格式】
k行，每行输出对应一个输入。
能办到则输出“YES”，否则输出“NO”。

【数据范围】

1≤n≤100 

【输入样例】

2
3
.##
..#
#..
0 0 2 2
5
.....
###.#
..#..
###..
...#.
0 0 4 0

【输出样例】

YES
NO

【解题思路】
常规dfs板板题
【CODE】

#include<iostream>
#include<cstring>

using namespace std;

const int N = 110;

char g[N][N];
bool st[N][N];
int n;
int l1, l2, r1, r2;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};

bool dfs(int x, int y){
    if(x == l2 && y == r2) return true;
    st[x][y] = true;
    
    for(int i = 0; i < 4; ++i){
        int a = x + dx[i];
        int b = y + dy[i];
        
        if(a < 0 || a >= n || b < 0 || b >= n) continue;
        if(g[a][b] == '#') continue;
        if(st[a][b]) continue;
        if(dfs(a, b)) return true;
    }
    return false;
}

int main(){
    int T;
    cin >> T;
    while( T --){
        memset(st, false, sizeof st);
        cin >> n;
        for(int i = 0; i < n; ++i) cin>>g[i];
        cin >> l1 >> r1 >> l2 >> r2;
        if(g[l1][r1] == '#' || g[l2][r2] == '#') {
            cout << "NO" << endl;
            continue;
        }
        if(dfs(l1, r1)) cout << "YES" << endl;
        else cout << "NO" << endl;
    }
    return 0;
}

0x02：红与黑

【题目】
有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。
你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。
请写一个程序，计算你总共能够到达多少块黑色的瓷砖。

【输入格式】
输入包括多个数据集合。
每个数据集合的第一行是两个整数 W 和 H ，分别表示 x 方向和 y 方向瓷砖的数量。
在接下来的 H 行中，每行包括 W 个字符。每个字符表示一块瓷砖的颜色，规则如下
1）‘.’：黑色的瓷砖；
2）‘#’：红色的瓷砖；
3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。
当在一行中读入的是两个零时，表示输入结束。
【输出格式】
对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。

【数据范围】

1≤W,H≤20 

【输入样例】

6 9 
....#. 
.....# 
...... 
...... 
...... 
...... 
...... 
#@...# 
.#..#. 
0 0

【输出样例】

45

【CODE】

#include<iostream>
#include<cstring>

using namespace std;

const int N = 30;

char g[N][N];
bool st[N][N];
int n, m;
int x, y;
int ans;
int dx[] = {-1, 0 ,1, 0}, dy[] = {0, 1, 0, -1};

void dfs(int x, int y){
    if(x < 0 || x >= m || y < 0 || y >= n || st[x][y] || g[x][y] == '#') return;
    st[x][y] = true;
    ans ++;
    for(int i = 0; i < 4; ++i){
        int a = x + dx[i];
        int b = y + dy[i];
        dfs(a, b);
    }
}

int main(){
    cin >> n >> m;
    while(n != 0 && m != 0){
        memset(st, false, sizeof st);
        ans = 0;
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                cin >> g[i][j];
                if(g[i][j] == '@'){
                    x = i;
                    y = j;
                }
            }
        }
        dfs(x, y);
        cout << ans << endl;
        cin >> n >> m;
    }
    
    return 0;
}

0x03：马走日

【题目】
马在中国象棋以日字形规则移动。
请编写一段程序，给定 n∗m 大小的棋盘，以及马的初始位置 (x，y) ，要求不能重复经过棋盘上的同一个点，计算马可以有多少途径遍历棋盘上的所有点。

【输入格式】
第一行为整数 T ，表示测试数据组数。
每一组测试数据包含一行，为四个整数，分别为棋盘的大小以及初始位置坐标 n,m,x,y 。
【输出格式】
每组测试数据包含一行，为一个整数，表示马能遍历棋盘的途径总数，若无法遍历棋盘上的所有点则输出 0。

【数据范围】

1≤T≤9 ,
1≤m,n≤9 ,
0≤x≤n−1 ,
0≤y≤m−1 

【输入样例】

1
5 4 0 0

【输出样例】

32

【解题思路】
dfs(x, y, step)分别表示，坐标和经过的点的个数
遍历每一种情况，并需要回溯记录所有情况
【CODE】

#include<iostream>
#include<cstring>

using namespace std;

const int N = 20;

int n, m, x, y;
bool g[N][N];
int dx[] = {-2, -2, -1, 1, 2, 2, -1, 1};
int dy[] = {-1, 1, 2, 2, -1, 1, -2, -2};
int ans;

void dfs(int x, int y, int step){
    if(step == n * m){
        ans ++;
        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]){
            g[a][b] = true;
            dfs(a, b, step + 1);
            g[a][b] = false; // 回溯
        }
    }
}

int main(){
    int T;
    cin >> T;
    while( T -- ){
        ans = 0;
        memset(g, false, sizeof g);
        cin >> n >> m >> x >> y;
        g[x][y] = true; // 起点标记
        dfs(x, y, 1);
        cout << ans << endl;
    }
    return 0;
}

参考文章

https://blog.csdn.net/qq_40763929/article/details/81629800