DFS：连通性与搜索顺序例题与详解acm

最新推荐文章于 2026-04-16 11:41:59 发布

原创最新推荐文章于 2026-04-16 11:41:59 发布 · 487 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#dfs #算法 #c++ #连通性 #搜索顺序

算法模板专栏收录该内容

36 篇文章

订阅专栏

本文通过多个实例介绍了深度优先搜索（DFS）的应用场景和技术细节，包括迷宫问题、红与黑游戏、N皇后问题等，涵盖了连通性模型与搜索顺序两大主题。

连通性与搜索顺序

#写在前面
#DFS之连通性模型
#DFS之搜索顺序

#写在前面

无

#DFS之连通性模型

只在同一个地图（状态）间走，不用回溯

##迷宫

https://www.acwing.com/problem/content/1114/

----c++版

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=110;
int n;
char g[N][N];
bool st[N][N];
int xa,ya,xb,yb;

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

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

int main(){
    int T;cin>>T;
    while(T--){
        cin>>n;
        for(int i=0; i<n; i++)cin>>g[i];
        memset(st, 0, sizeof st);
        cin>>xa>>ya>>xb>>yb;
        
        if(dfs(xa, ya))puts("YES");
        else puts("NO");
    }
    
    return 0;
}

##红与黑

https://www.acwing.com/problem/content/1115/

----c++版

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=25;

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

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

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

#DFS之搜索顺序

也就是带回溯的DFS

##n皇后

----c++版

https://www.acwing.com/problem/content/845/

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=20;
int n;
char g[N][N];
bool col[N],dg[N],udg[N];
void dfs(int u){
    if(u==n){
        for(int i=0;i<n;i++)puts(g[i]);
        puts("");
        return;
    }
    for(int i=0;i<n;i++){
        if(!col[i]&&!dg[u+i]&&!udg[n-u+i]){
            g[u][i]='Q';
            col[i]=dg[u+i]=udg[n-u+i]=true;
            dfs(u+1);
            col[i]=dg[u+i]=udg[n-u+i]=false;
            g[u][i]='.';
        }
    }
}
int main(){
    cin>>n;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            g[i][j]='.';
    dfs(0);return 0;
}

##马走日

https://www.acwing.com/problem/content/1118/

----c++版

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=10;
int n,m;
bool st[N][N];
int ans;

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

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

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

##单词接龙

https://www.acwing.com/problem/content/1119/

----c++版

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=22;

int n;
string word[N];
int g[N][N];//用初始化的方式，将词看成点，能接上看成点间有边，用邻接矩阵存图
int used[N];
int ans;

void dfs(string dragon, int last){
    ans=max((int)dragon.size(), ans);
    used[last]++;
    
    for(int i=0; i<n; i++)
        if(g[last][i] && used[i]<2)
            dfs(dragon+word[i].substr(g[last][i]), i);
    
    used[last]--;
}

int main(){
    cin>>n;
    for(int i=0; i<n; i++) cin>>word[i];
    char start;
    cin>>start;
    
    for(int i=0; i<n;i++)
        for(int j=0; j<n; j++){
            string a=word[i], b=word[j];
            for(int k=1; k<min(a.size(), b.size()); k++)
                if (a.substr(a.size()-k, k)==b.substr(0,k)){
                    g[i][j]=k;
                    break;
                }
        }
    
    for(int i=0; i<n; i++)
        if(word[i][0]==start)
            dfs(word[i], i);
            
    cout<<ans<<endl;
    return 0;
}

##互分质数组

https://www.acwing.com/problem/content/1120/
在这里插入图片描述

----c++版

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=10;
int n;
int a[N];
int g[N][N];
int ans=N;
int st[N];

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

bool check(int g[], int x, int start){
    for(int i=0; i<start; i++)
        if(gcd(g[i], x)>1) return false;
    return true;
}
//当前要放在哪个分组；要放在该分组的第几个位置；从哪个位置开始选择元素【组合套路(定一个遍历顺序)】；当前已分组完毕的元素个数
void dfs(int gr, int gc, int start, int cnt){
    if(gr>=ans)return;
    if(cnt==n)ans=gr;
    
    bool flag=true;
    for(int i=start; i<n; i++)//原数列剩下的数中，是否还存在可以放到当前组中的数
        if(!st[i] && check(g[gr], a[i], gc)){
            st[i]=true;
            g[gr][gc]=a[i];
            dfs(gr, gc+1, i+1, cnt+1);
            st[i]=false;
            flag=false;
        }
    //如果不存在，重新建组，由于前一组选数字时候可能漏掉几个，所以新一组start要从0开始找
    //对每一组来说，其中的数字在a中的下标都是递增的。
    if(flag) dfs(gr+1, 0, 0, cnt);
}

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