DFS中的连通性和搜索顺序

ZZTC

已于 2024-12-30 13:37:17 修改

阅读量480

点赞数 16

分类专栏：算法文章标签：深度优先算法

于 2024-12-30 13:27:41 首次发布

本文链接：https://blog.youkuaiyun.com/qq_73628657/article/details/144823600

版权

算法专栏收录该内容

23 篇文章

订阅专栏

DFS之连通性模型

关于连通性问题，一般既可以用 DFS 来求解，也可以使用 BFS 来求解：

DFS 代码好写一些，但是容易爆栈，而且不能求最小值
BFS 代码较长，消耗的空间较大，可以求最小值

1112. 迷宫

一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由 $n * n$ 的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。

同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。

如果起点或者终点有一个不能通行(为#)，则看成无法办到。

注意：A、B不一定是两个不同的点。

输入格式

第1行是测试数据的组数 $k$ ，后面跟着 $k$ 组输入。

每组测试数据的第1行是一个正整数 $n$ ，表示迷宫的规模是 $n * n$ 的。

接下来是一个 $n * n$ 的矩阵，矩阵中的元素为.或者#。

再接下来一行是 4 个整数 $h_a,l_a,h_b,l_b$ ，描述 $A$ 处在第 $h_a$ 行, 第 $l_a$ 列， $B$ 处在第 $h_b$ 行, 第 $l_b$ 列。

注意到 $h_a,l_a,h_b,l_b$ 全部是从 0 开始计数的。

输出格式

$k$ 行，每行输出对应一个输入。

能办到则输出“YES”，否则输出“NO”。

数据范围

$1 \leq n \leq 100$

输入样例：

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

输出样例:

YES
NO

这是一道 DFS 的板子裸题

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 110;
int k, n, ha, la, hb, lb, dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
char g[N][N];
bool st[N][N];

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

int main(){
    cin >> k;
    while(k--){
        memset(st, false, sizeof st);
        cin >> n;
        for (int i = 0; i < n; i++) cin >> g[i];
        cin >> ha >> la >> hb >> lb;
        if(g[ha][la] == '#' || g[hb][lb] == '#') cout << "NO" << endl;
        else if(dfs(ha, la)) cout << "YES" << endl;
        else cout << "NO" << endl;
    }
    return 0;
}

1113. 红与黑

有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。

你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。

请写一个程序，计算你总共能够到达多少块黑色的瓷砖。

输入格式

输入包括多个数据集合。

每个数据集合的第一行是两个整数 $W$ 和 $H$ ，分别表示 $x$ 方向和 $y$ 方向瓷砖的数量。

在接下来的 $H$ 行中，每行包括 $W$ 个字符。每个字符表示一块瓷砖的颜色，规则如下

1）‘.’：黑色的瓷砖；
2）‘#’：红色的瓷砖；
3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。

当在一行中读入的是两个零时，表示输入结束。

输出格式

对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。

数据范围

$1 \leq W, H \leq 20$

输入样例：

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

输出样例：

这也是一道 DFS 的板子裸题

#include<iostream>
#include<cstring>
using namespace std;
const int N = 25;
int w, h, res, dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1}, x, y;
char g[N][N];
bool st[N][N];

void dfs(int xx, int yy){
    res++;
    st[xx][yy] = true;
    for (int i = 0; i < 4; i++){
        int tx = xx + dx[i], ty = yy + dy[i];
        if(tx < 0 || tx >= h || ty < 0 || ty >= w || st[tx][ty] || g[tx][ty] == '#') continue;
        st[tx][ty] = true;
        dfs(tx, ty);
    }
}

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

DFS之搜索顺序

1116. 马走日

马在中国象棋以日字形规则移动。

请编写一段程序，给定 $n * m$ 大小的棋盘，以及马的初始位置 $(x ， y)$ ，要求不能重复经过棋盘上的同一个点，计算马可以有多少途径遍历棋盘上的所有点。

输入格式

第一行为整数 $T$ ，表示测试数据组数。

每一组测试数据包含一行，为四个整数，分别为棋盘的大小以及初始位置坐标 $n, m, x, y$ 。

输出格式

每组测试数据包含一行，为一个整数，表示马能遍历棋盘的途径总数，若无法遍历棋盘上的所有点则输出 0。

数据范围

$1 \leq T \leq 9$ ,
$1 \leq m, n \leq 9$ ,
$1 \leq n \times m \leq 28$ ,
$0 \leq x \leq n - 1$ ,
$0 \leq y \leq m - 1$

输入样例：

1
5 4 0 0

输出样例：

板子题

#include<iostream>
#include<cstring>
using namespace std;
const int N = 10;
int t, n, m, x, y, dx[8] = {-1, -2, -2, -1, 1, 2, 2, 1}, dy[8] = {-2, -1, 1, 2, 2, 1, -1, -2}, ans;
bool st[N][N];

void dfs(int xx, int yy, int cnt){
    if(cnt == n * m){
        ans++;
        return;
    }
    st[xx][yy] = true;
    for (int i = 0; i < 8; i++){
        int tx = xx + dx[i], ty = yy + dy[i];
        if(tx < 0 || tx >= n || ty < 0 || ty >= m || st[tx][ty]) continue;
        st[tx][ty] = true;
        dfs(tx, ty, cnt + 1);
        st[tx][ty] = false;
    }
}

int main(){
    cin >> t;
    while(t--){
        cin >> n >> m >> x >> y;
        memset(st, false, sizeof st);
        ans=0;
        dfs(x, y, 1);
        cout << ans << endl;
    }
    return 0;
}

1117. 单词接龙

单词接龙是一个与我们经常玩的成语接龙相类似的游戏。

现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”，每个单词最多被使用两次。

在两个单词相连时，其重合部分合为一部分，例如 beast 和 astonish ，如果接成一条龙则变为 beastonish。

我们可以任意选择重合部分的长度，但其长度必须大于等于1，且严格小于两个串的长度，例如 at 和 atide 间不能相连。

输入格式

输入的第一行为一个单独的整数 $n$ 表示单词数，以下 $n$ 行每行有一个单词（只含有大写或小写字母，长度不超过20），输入的最后一行为一个单个字符，表示“龙”开头的字母。

你可以假定以此字母开头的“龙”一定存在。

输出格式

只需输出以此字母开头的最长的“龙”的长度。

数据范围

$n \leq 20$ ，
单词随机生成。

输入样例：

5
at
touch
cheat
choose
tact
a

输出样例：

提示

连成的“龙”为 atoucheatactactouchoose。

#include<iostream>
#include<string>
#include<iostream>
#include<unordered_map>
using namespace std;
const int N = 25;
int n, num;
string s[N];
unordered_map<string, int> mp;

int f(string s1, string s2){
    int ans = max(s1.length(), s2.length());
    int j = min(s1.length(), s2.length());
    while(j > 0){ 
        if(s1.substr(s1.length() - j, j) == s2.substr(0, j)) ans = min(ans, j);
        j--;
    }
    if(ans == s1.length() || ans == s2.length()) return 0;
    return ans;
}

void dfs(string ss){
    if(ss.length() > num) num = ss.length();
    for (int i = 0; i < n; i++){
        int len = f(ss, s[i]);
        if(len && mp[s[i]] < 2){
            string ts = ss + s[i].substr(len);
            mp[s[i]]++;
            dfs(ts);
            mp[s[i]]--;
        }
    }
}

int main(){
    cin >> n;
    for (int i = 0; i < n; i++) cin >> s[i];
    char first;
    cin >> first;
    for (int i = 0; i < n; i++){
        if(s[i][0] == first) {
            mp[s[i]] = 1;
            dfs(s[i]);
            mp[s[i]] = 0;
        }
    }
    cout << num << endl;
    return 0;
}

注意：在 f 函数中求重合部分应该取最小值，这样才能保证裁剪拼接得到的字符串才能最长

1118. 分成互质组

给定 $n$ 个正整数，将它们分组，使得每组中任意两个数互质。

至少要分成多少个组？

输入格式

第一行是一个正整数 $n$ 。

第二行是 $n$ 个不大于 $10000$ 的正整数。

输出格式

一个正整数，即最少需要的组数。

数据范围

$1 \leq n \leq 10$

输入样例：

6
14 20 33 117 143 175

输出样例：

什么叫互质？公约数只有 $1$ 的两个数叫做互质数。根据这一定义可以对一组数是否互质进行判断。如： $2$ 和 $7$ 的公约数只有 $1$ ，则它们是互质数。

思路：

对每一组进行 DFS 遍历操作，如果当前数据能够加入到这一组中，则将其添加进当前组
如果任何数据都无法满足，则开一个新的组进行 DFS 遍历操作

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 15;
int n, p[N], group[N][N], ans = N;
bool st[N];

int gcd(int a, int b){
    return b ? gcd(b, a % b) : a;
}

bool check(int g[], int num, int cnt){
    for (int i = 0; i < cnt; i++){
        if(gcd(p[g[i]], num) > 1) return false;
    }
    return true;
}

// 第g组，这组现在有gc个元素，总共加了tc个元素，这组选择从下标start开始
void dfs(int g, int gc, int tc, int start){
    if(g >= ans) return;
    if(tc == n) ans = g;
    bool flag = true;
    for (int i = start; i < n; i++){
        if(!st[i] && check(group[g], p[i], gc)){
            st[i] = true;
            group[g][gc] = i;
            dfs(g, gc + 1, tc + 1, i + 1);
            st[i] = false;
            flag = false;
        }
    }
    if(flag) dfs(g + 1, 0, tc, 0);
}

int main(){
    cin >> n;
    for (int i = 0; i < n; i++) cin >> p[i];
    dfs(1, 0, 0, 0);
    cout << ans << endl;
    return 0;
}

了解更多内容，详见个人博客：ZZZTC的daily