DFS专题

已于 2023-05-30 23:36:39 修改
阅读量401 收藏 1
点赞数
分类专栏： 【237题】算法基础精选题单 文章标签： 深度优先 算法 c++
于 2023-05-30 22:54:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangcha_xyy/article/details/130208760
版权

题单地址：【237题】算法基础精选题单_ACM竞赛_ACM/CSP/ICPC/CCPC/比赛经验/题解/资讯_牛客竞赛OJ_牛客网

老子的全排列呢

dfs+回溯

int n = 8;
int idx;
int record[10];
bool vis[10];

void dfs(int num)
{
	if(num==n){
		for(int i=1;i<=n;i++) cout<<record[i]<<" ";
		cout<<endl;
		return ;
	}
	for(int i=1;i<=n;i++){
		if(!vis[i]){
			vis[i] = true;
			record[++idx] = i;
			dfs(num+1);
			record[idx--] = 0;
			vis[i] = false;
		}
	}

}

N皇后问题

O(n!)

 借用一位博主的图说明x+y和x-y+n的

const int N = 15*2;
int n,ans;
int col[N],dig[N],undig[N];

void dfs(int u)//u代表行数
{
	if(u == n){//已经搜索了n行
		ans++;
		return ;
	}
	for(int y=0;y<n;y++){
		if(!col[y] && !dig[u+y] && !undig[u-y+n]){
			col[y] = dig[u+y]  = undig[u-y+n] = true;
			dfs(u+1);
			col[y] = dig[u+y]  = undig[u-y+n] = false;
		}
	}
}

void solve()
{
	cin>>n;
	dfs(0);
	cout<<ans<<endl;
}

O(2^(n*n))

TLE的写法,想想就可怕

const int N = 15*2;
int n,ans;
int col[N],row[N],dig[N],undig[N];

void dfs(int x,int y,int u)
{
	if(y==n){
		x++;
		y=0;
	}
	if(x==n){
		if(u==n) ans++;
		return;
	}

	//不放
	dfs(x,y+1,u);
	//放
	if(!col[y]&&!row[x]&&!dig[x-y+n]&&!undig[x+y]){
		col[y] = row[x] = dig[x-y+n] = undig[x+y] = true;
		dfs(x,y+1,u+1);
		col[y] = row[x] = dig[x-y+n] = undig[x+y] = false;
	}

}

void solve()
{
	cin>>n;
	dfs(0,0,0);
	cout<<ans<<endl;
}

马踏棋盘

走迷宫的写法，和迷宫的上下左右稍有不同，深搜时注意别越界且前往的点上没走过即可

#define PII pair<int,int>
const int N = 15+2;
int n,m;
const PII dir[4] = {{1,2},{2,1},{-1,2},{-2,1}};
bool vis[N][N];
int ans;

bool in(int x,int y)
{
	return (x>=1 && x<=n && y>=1 && y<=m);
}

void dfs(int x,int y)
{
	if(x==n && y==m){
		ans++;
		return;
	}

	for(int i=0;i<4;i++){
		int tx = dir[i].first+x;
		int ty = dir[i].second+y;
		if(in(tx,ty) && !vis[tx][ty]){
			vis[tx][ty] = true;
			dfs(tx,ty);
			vis[tx][ty] = false;
		}
	}
}

void solve()
{
	cin>>n>>m;
	vis[1][1] = true;
	dfs(1,1);
	cout<<ans<<endl;
}

数独挑战

dfs+剪枝，棋盘格子看起来很多觉得会TLE，实际上考虑上数独的规则进行剪枝还是可以过的。

分为三部分记录棋盘信息：行、列、块，块分为

 11 |  12 | 13

 21 |  22 | 23

 31 |  32 | 33

一共九个部分，(x,y)在某一块可以用[x/3][y/3]来确定位置

其余的部分和常规dfs相差无几，注意的是回溯的时候不能都置为0，只有你自己填的数可以删掉，题目原来给的数不能删，所以要额外开一个origin数组记录哪些位置是一开始就有数的

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define fasten cin.tie(0),cout.tie(0);ios::sync_with_stdio(false)

const int N = 10+2;
int g[N][N];
bool row[N][10];//第i行的1-9各有几个
bool col[N][10];
bool block[4][4][10];//左上角的块为1,1 依次为1,2 1,3 ... 
int blank = 81;//待填的空格
int origin[N][N];//记录原始给定的数字，回溯时不能删除
void print(){
    for(int i=0;i<9;i++){
        for(int j=0;j<9;j++){
            cout<<g[i][j]<<" ";
        }
        cout<<endl;
    }
}
void dfs(int x,int y)
{
    if(y==9){
        y = 0;
        x++; 
    }
    if(blank==0){
        print();
        return ;
    }
    if(g[x][y]!=0) dfs(x,y+1);
    bool flag = false;//记录该格子是否还能填数，不能的话该搜索路径不用搜索下去了
    for(int i=1;i<=9;i++){
        if(!block[x/3][y/3][i] && !row[x][i] && !col[y][i]){
            flag = true;
            g[x][y] = i;
            block[x/3][y/3][i] = row[x][i] = col[y][i] = true;
            blank--;
            dfs(x,y+1);
            blank++;
            //若是自己填的数就回溯为0，系统给定的数不能改动
            if(origin[x][y]) g[x][y] =origin[x][y];
            else g[x][y] = 0;
            block[x/3][y/3][i] = row[x][i] = col[y][i] = false;
        }
    }
    if(!flag) return ;

}
void solve()
{
    for(int i=0;i<9;i++){
        for(int j=0;j<9;j++){
            cin>>g[i][j];
            origin[i][j] = g[i][j];
            if(g[i][j]!=0){
                int e = g[i][j];
                blank--;
                row[i][e] = true;
                col[j][e] = true;
                block[i/3][j/3][e] = true;
            }
        }
    }
    //debug
    // for(int i=1;i<=9;i++) cout<<i<<" ";
    // cout<<endl;
    // for(int i=0;i<3;i++){
    //     for(int k=0;k<3;k++){
    //         for(int j=1;j<=9;j++){
    //             cout<<block[i][k][j]<<" ";
    //         }
    //         cout<<endl;
    //     }
    // }
    dfs(0,0);

}
signed main()
{
    fasten;
//     freopen("stdin.txt","r",stdin);
//     freopen("stdout.txt","w",stdout);
    solve();
    return 0;
}

幸运数字Ⅱ

可以先用dfs把所有只含4or7且<=1e9的数处理出来放在一个容器内，然后再[l,r]内使用二分计算总和，用string比用long long快大约100倍左右

#define PII pair<int,int>
#define ll long long
vector<ll>v;

void dfs(string s,int digit)
{
	if(digit>9){
		return ;
	}
	int tmp = 0;
	for(int i=0;i<s.length();i++){
		tmp = tmp*10+(s[i]-'0');
	}
	if(tmp<1e9){
		if(tmp!=0) v.push_back(tmp);
		dfs("4"+s,digit+1);
		dfs("7"+s,digit+1);
	}
}

void solve()
{
	dfs("",0);
	v.push_back(4444444444);
	sort(v.begin(),v.end());
	// for(auto it:v){
	// 	cout<<it<<endl;
	// }
	long long l,r;
	cin>>l>>r;
	long long res = 0;
	for(ll i=l;i<=r;){
		auto it = lower_bound(v.begin(),v.end(),i);
		res += min(r-i+1ll,(*it-i+1ll))*(*it);
		i = *it+1;
	}
	cout<<res<<endl;
}

[NOIP2017]奶酪

回溯dfs写法会超时，别写回溯写法

有的题目一定要回溯，但是有的题目不用回溯，选择不回溯可以优化算法

那什么时候不需要回溯？

当遇到一个选择时，一定要对它操作时，那么就不需要回溯。比如要标记求所有情况，找到了就要标记。如果取消标记，那么就会重复计算。在这道题中，小鼠尝试通过空洞从起点到终点，到达一个点时，小鼠需要知道该点范围内的可到达的点中有没有能到达终点的点，如果有的点不能到达终点，就不必再走那个点了。

如何知道该点能不能达到终点？

dfs搜索时会直接搜索到最深处，接着从底层一层一层往上反馈该点能不能通往终点。该点若已经搜索过，必定打上了标记（回溯则会把该标记划去，那就需要重复搜索了）

AC版本

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define fasten cin.tie(0),cout.tie(0);ios::sync_with_stdio(false)


const int N = 1000+2;
int n;
int h,r;
bool vis[N];//记录该空洞有没有走过
bool g[N][N];
int x[N],y[N],z[N];
bool isfind = false;

bool dfs(int i)
{
    if(z[i]+r>=h){
        return true;
    }
    if(vis[i]) return false;
    vis[i] = true;
    for(int j=0;j<n;j++){
        if(g[i][j] && dfs(j)) return true;
    }
    return false;
}

void solve()
{
    int t;
    cin>>t;
    while(t--){
        memset(g,0,sizeof g);
        memset(vis,0,sizeof vis);
        cin>>n>>h>>r;
        for(int i=0;i<n;i++){
            cin>>x[i]>>y[i]>>z[i];
        }

        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i!=j)g[i][j]=g[j][i]=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+
                                  (z[i]-z[j])*(z[i]-z[j]) <=4*r*r;
            }
        }
        for(int i=0;i<n;i++){
            if(z[i]<=r){
                if(dfs(i)){
                    puts("Yes");
                    isfind = true;
                    break;
                }
            }
        }
        if(!isfind) puts("No");
        isfind = false;
    }
}
signed main()
{
    fasten;
//     freopen("stdin.txt","r",stdin);
//     freopen("stdout.txt","w",stdout);
    solve();

    return 0;
}

TLE版本

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define fasten cin.tie(0),cout.tie(0);ios::sync_with_stdio(false)

class point
{
public:
    double x,y,z;
    point(){};
    point(int a,int b,int c){x=a,y=b,z=c;}
};

double dist(point p1,point p2)
{
    double x = (p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y)+(p1.z-p2.z)*(p1.z-p2.z);
    return sqrt(x);
}
const int N = 1000+2;
point a[N];
int n;
double h,r;
bool vis[N];//记录该空洞有没有走过
bool g[N][N];
bool isfind = false;

void dfs(int x,int y,int z,int idx)
{
    if(z+r>=h){
        isfind = true;
        return ;
    }
    for(int i=0;i<n;i++){
        point tmp(x,y,z);
        if(!vis[i] && g[idx][i]){
            vis[i] = true;
            dfs(a[i].x,a[i].y,a[i].z,i);
            vis[i] = false;
        }
    }

}
void solve()
{
    int t;
    cin>>t;
    while(t--){
        memset(g,0,sizeof g);
        cin>>n>>h>>r;
        for(int i=0;i<n;i++){
            cin>>a[i].x>>a[i].y>>a[i].z;
        }

        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i!=j)g[i][j] = dist(a[i],a[j])<=2*r;
            }
        }
        for(int i=0;i<n;i++){
            if(a[i].z<=r) dfs(a[i].x,a[i].y,a[i].z,i);
        }
        if(isfind) puts("Yes");
        else puts("No");
        isfind = false;
    }
}
signed main()
{
    fasten;
//     freopen("stdin.txt","r",stdin);
//     freopen("stdout.txt","w",stdout);
    solve();

    return 0;
}

wyh的迷宫

迷宫问题不在赘述

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define fasten cin.tie(0),cout.tie(0);ios::sync_with_stdio(false)
#define PII pair<int,int>
const int N = 500+2;
int n,m;
const PII dir[4] = {{0,1},{1,0},{-1,0},{0,-1}};
bool vis[N][N];
string s[N];
PII _begin,_end;
bool isfind = false;

bool in(int x,int y)
{
	return (x>=1 && x<=n && y>=1 && y<=m);
}

void dfs(int x,int y)
{
    //cout<<x<<" "<<y<<endl;
    if(x==_end.first && y==_end.second){
        isfind = true;
        return ;
    }
	for(int i=0;i<4;i++){
		int tx = dir[i].first+x;
		int ty = dir[i].second+y;
		if(in(tx,ty) && !vis[tx][ty] && s[tx][ty]!='x'){
            if(x==_end.first && y==_end.second){
                isfind = true;
                return ;
            }
			vis[tx][ty] = true;
			dfs(tx,ty);
		}
	}
    return ;
}

void solve()
{
    int t;
    cin>>t;
    while(t--){
        memset(vis,0,sizeof vis);
        cin>>n>>m;
        for(int i=1;i<=n;i++) cin>>s[i],s[i]=" "+s[i];
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(s[i][j]=='s') _begin = {i,j};
                else if(s[i][j]=='t') _end = {i,j};
            }
        }
        vis[_begin.first][_begin.second] = true;
        dfs(_begin.first,_begin.second);
        if(isfind) cout<<"YES"<<endl;
        else cout<<"NO"<<endl;
        isfind = false;
    }
}


signed main()
{
    fasten;
//     freopen("stdin.txt","r",stdin);
//     freopen("stdout.txt","w",stdout);
    solve();
    return 0;
}

Lake Counting

求连通分支的个数，可用并查集的知识

也可以直接搜索，标记访问过的点，查看有几块

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define fasten cin.tie(0),cout.tie(0);ios::sync_with_stdio(false)
#define PII pair<int,int>
const int N = 100+5;
char s[N][N];
int n,m;
int ans;
const PII dir[8] = {{1,0},{1,1},{1,-1},{0,1},
                    {0,-1},{-1,1},{-1,0},{-1,-1}};

bool in(int x,int y)
{
    return (x>=0 && x<n && y>=0 && y<m);
}

void dfs(int x,int y)
{
    s[x][y] = '.';//走过的修改成陆地
    for(int i=0;i<8;i++){//八个方向都可走
        int tx = x+dir[i].first;
        int ty = y+dir[i].second;
        if(in(tx,ty) && s[tx][ty]=='W'){
            dfs(tx,ty);
        }
    }
    return ;
}
void solve()
{
    cin>>n>>m;
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            cin>>s[i][j];
        }
    }
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            if(s[i][j]=='W'){
                dfs(i,j);
                ans++;
            }
            
        }
    }
    cout<<ans<<endl;
}


signed main()
{
    fasten;
//     freopen("stdin.txt","r",stdin);
//     freopen("stdout.txt","w",stdout);
    solve();
    return 0;
}

liangchaaaaa
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
搜索专题——DFS
12-17
【DFS搜索】 深度优先搜索（Depth-First Search，简称DFS）是一种用于遍历或搜索树或图的算法。在这个搜索过程中，算法尽可能深地探索树的分支。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始...
dfs专题
qq_52011873的博客
07-16 125
一丶 Oil Deposits The GeoSurvComp geologic survey company is responsible for detecting underground oil deposits. GeoSurvComp works with one large rectangular region of land at a time, and creates a grid that divides the land into numerous square plots. It t
leetcode算法专题训练：十.DFS专题
Worthy_Wang的博客
01-29 488
十.DFS专题 130.被围绕的区域 131.分割回文串 132.分割回文串2 87.扰乱字符串 剑指 Offer 13. 机器人的运动范围 36.有效的数独 37.解数独 51.N皇后 52.N皇后2 149.直线上最多的点数 93.复原IP地址 39.组合总合 40.组合总合2 22.括号生成 79.单词搜索 十.DFS专题 130.被围绕的区域 题目描述:给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。 找到所有被 ‘X’ 围绕的区域，并将这些区域.
蓝桥杯DFS专题
maple_lv的博客
02-02 353
DFS
DFS专题练习
Xpy_021101的博客
04-07 85
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有 2 座岛屿。请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
简单dfs专题
林鸿清的blog
08-05 470
由于被状压DP打自闭，觉着来dfs找找自信，没成想依旧自闭orz   HDU 2610 Sequence one 题意： 给出n个数字，让你求出非递减序列，且个数&lt;p （ find the first P subsequences 前p个，当时怎么就没get呢）。序列的顺序是和下标有关的，也就是说按下标排序，不能出现重复。 思路： dfs(last , now , len )，m...
leetcode DFS专题
陌上烟雨遥的博客
02-05 194
1 DFS 框架 result = [] void backtrack(路径，选择列表) { if (满足条件) { result.add(路劲); return; } for 选择 in 选择列表 做选择 backtrack(路径，选择列表); 撤销选择 } ...
蓝桥dfs专题
RGHLY21的博客
03-08 444
蓝桥dfs专题
【蓝桥杯】dfs专题
涛涛的个人博客
03-25 2068
蓝桥杯之dfs
leetcode dfs专题
qq_23128065的博客
03-05 186
每次遇到dfs，回溯这些就不会做，刷了几道题之后大概能总结出模板，后续有更多套路再补充。 public List<String> function(String s){ List<String> res = new ArrayList<String>(); dfs(res,strat,temp); } public void dfs(Lis...
acm的DP专题
06-11
ACM DP 专题 ACM DP 专题是指在 ACM 竞赛中关于动态规划（DP）问题的专题。动态规划是一种常用的算法设计技术，用于解决具有最优子结构的问题。动态规划的问题通常具有两个特点：最优子结构和重叠子问题。最优子...
搜索专题
06-10
- **应用**：在题目中，DFS 被用来解决如何用给定的小棍拼凑成特定长度的问题。具体来说，DFS 用来寻找所有可能的组合方式，并检查这些组合是否满足最终的目标长度。 - **优化技巧**： - **剪枝**：为了避免不必...
第二讲：复习专题之链表,指针,dfs&bfs.pptx
10-05
在C++编程语言中，链表、指针、深度优先搜索(DFS)和广度优先搜索(BFS)是重要的概念，这些概念在处理数据结构和算法时尤其关键。本讲将详细阐述这些主题。 首先，我们来看结构体，它是C++中定义自定义数据类型的一种...
HDU 专题分类（2013年8月）
08-07
- **问题描述**：此题可能涉及图的遍历，特别是深度优先搜索(DFS)或广度优先搜索(BFS)，用于寻找森林中两点间的一条路径。 - **算法应用**：最短路径算法如Dijkstra或Bellman-Ford，用于计算两点之间的最短路径。 #...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5138
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
学习C语言第12天（数组练习）
2301_79600945的博客
07-24 636
把任意数字从中间拆分拆分后的乘积之和等于自身，则是一个水仙花。例如：655=6*55+65*5。
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3349
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
【算法】退火算法 Simulated Annealing
最新发布
藓类少女的博客
07-25 1402
退火算法（Simulated Annealing, SA）是一种基于热力学模拟的优化算法，用于求解全局优化问题。它通过模拟物理退火过程来寻找全局最优解。
ACM专题：搜索算法详解
ACM专题讲座深入探讨了搜索算法，将人类的思维过程与搜索过程相联系，强调了许多问题可以通过状态空间的搜索来解决。 1. 搜索问题 搜索问题通常涉及在给定的约束条件下找到从初始状态到目标状态的路径。例如，传教...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值