连通性DFS例题

引入

跟BFS一样，DFS同样能解决连通性的问题；

但是DFS第一次走到某个点的时候，它的距离不一定是最短的；

而BFS则可以保证；

DFS只能保证某两个点是否连通；

是否回溯？

一般来说，像迷宫这种问题，将每个格子作为一种状态的，我们是不需要回溯的（具体原因看下方题面的思路处）；

---

而如果像棋盘这种将整个棋盘看成一个点的，我们就需要去回溯；

---

因为我们最终的目的是搜索完全部的状态，以整体去变换的，我们搜索完一个分支需要回溯才能搜索另一个分支；

而像迷宫这种，以一个个格子为一个个状态，就不需要回溯了；

总之记住一点，回溯是为了搜索全部的状态，如果不回溯就能搜索全部的状态，那么就没必要回溯；

例题

迷宫1

题面

传送门

思路

需要注意起点和终点可能是障碍物，题目没有保证不是；

因为我们只需要判断是否连通；

假设你从点$u$扩展不到终点，那么你从点$v$扩展$u$就没必要再搜索一次了，因为第一次扩展$u$的时候就已经把所有状态都跑完了；

因此不需要回溯；

Code

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 1e2 + 10;

int dx[] = {-1,1,0,0};
int dy[] = {0,0,-1,1};

int n;

char G[N][N];

int sx,sy,ex,ey;

bool vis[N][N];

bool dfs(int x,int y){
    //起点和终点可能是'#'
    if(G[x][y] == '#') return 0;
    if(x == ex && y == ey) return 1;
    vis[x][y] = 1;
    for(int i=0,xx,yy;i<4;++i){
        xx = x + dx[i];
        yy = y + dy[i];
        if(xx < 0 || xx >= n || yy < 0 || yy >= n) continue;
        if(vis[xx][yy]) continue;
        if(dfs(xx,yy)) return 1;
    }
    
    return 0;
}

void solve(){
    memset(vis,0,sizeof vis);
    cin >> n;
    for(int i=0;i<n;++i) cin >> G[i];
    cin >> sx >> sy >> ex >> ey;
    bool flag = dfs(sx,sy);
    if(flag) cout << "YES\n";
    else cout << "NO\n";
}

int main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    int t;
    cin >> t;
    while(t--)
        solve();
    return 0;
}

迷宫2

题面

传送门

思路

这题就是一个求最小值的迷宫，一般用BFS写起来更舒服我觉得…

关于为什么不需要回溯，如果到了某个点(记为$u$)，我们会将这个点能到的地方都搜索一遍；

如果从另外一个点$v$到这个点$u$，再去搜索的话，就搜索了重复的状态了；

因此保证每个点只搜索一次即可；

Code

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 1e2 + 10;

int dx[] = {-1,1,0,0};
int dy[] = {0,0,-1,1};

char G[N][N];

int sx,sy,n,m,ans = 1e9;

bool vis[N][N];

void dfs(int x,int y,int step){
    if(x == n && y == m){
        ans = min(ans,step);
    }
    vis[x][y] = 1;
    for(int i=0,xx,yy;i<4;++i){
        xx = x + dx[i];
        yy = y + dy[i];
        if(xx < 1 || xx > n || yy < 1 || yy > m) continue;
        if(G[xx][yy] == '#' || vis[xx][yy]) continue;
        dfs(xx,yy,step+1);
    }
}

void solve(){
    cin >> n >> m;
    for(int i=1;i<=n;++i) cin >> (1+G[i]);
    dfs(1,1,1);
    cout << ans << '\n';
}

int main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    solve();
    return 0;
}

红与黑

题面

传送门

思路

就是求当前点到所有点的连通块是多大；

这题其实就是dfs版本的Flood Fill问题，至于Flood Fill是什么，点我

Code

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 1e2 + 10;

int dx[] = {-1,1,0,0};
int dy[] = {0,0,-1,1};

char G[N][N];

int sx,sy,n,m,res;

bool vis[N][N];

void dfs(int x,int y){
    for(int i=0,xx,yy;i<4;++i){
        xx = x + dx[i],yy = y + dy[i];
        if(xx > n || xx < 1 || yy > m || yy < 1) continue;
        if(G[xx][yy] == '#') continue;
        if(vis[xx][yy]) continue;
        vis[xx][yy] = 1;
        ++res;
        dfs(xx,yy);
    } 
}

void solve(){
    memset(vis,0,sizeof vis);
    for(int i=1;i<=n;++i) cin >> (1+G[i]);
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
            if(G[i][j] == '@') sx = i,sy = j;
    vis[sx][sy] = 1;
    res = 1;
    dfs(sx,sy);
    cout << res << '\n';
}

int main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    //注意这里先列后行
    while(cin >> m >> n,(m||n))
        solve();
    return 0;
}