DFS（11）

最新推荐文章于 2022-05-21 19:20:08 发布
最新推荐文章于 2022-05-21 19:20:08 发布
阅读量166 收藏
点赞数
分类专栏： 基础算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mumuhaoshuai/article/details/100666673
版权

DFS（主要还是靠大家慢慢理解）

说实话，写这种博客我也挺难的。。。
因为他的内容太不好理解了
也没得什么好说的，直接做题理解吧。

先来一个特别有意思的递归题。

传送门： 放苹果 POJ - 1664 

#include <stdio.h>
using namespace std;
typedef long long ll;
int n,m,ans;
int DFS(int m,int n)
{
	if(n==0||n==1)
		return 1;
	if(n>m)
		return DFS(m,m);
	else
		return DFS(m-n,n)+DFS(m,n-1);
	
}
int main()
{ 	int T;
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d %d",&m,&n);
		printf("%d\n",DFS(m,n));

	}
	return 0;
	
}

传送门：Red and Black HDU - 1312

是不是感觉特熟悉，没错，上次写这个题用的是BFS，这次用的是DFS

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int xx,yy,x11,y11,ans;
char c[25][25];
int vis[25][25];
int dd[4][2]={1,0,-1,0,0,1,0,-1};
void DFS(int x,int y)
{
	vis[x][y]=1;
	if(x<0||y<0||x>=xx||y>=yy)	
		return ;
	for(int i=0;i<4;i++)
	{
		int dx=x+dd[i][0];
        int dy=y+dd[i][1];
        if(dx>=0&&dy>=0&&dx<xx&&dy<yy&&vis[dx][dy]==0&&c[dx][dy]!='#')
        {
        	ans++;
        	DFS(dx,dy);
		}
	}
}

int main()
{
	while(~scanf("%d %d",&yy,&xx)&&yy&&xx)
	{
		ans=1;
		memset(vis,0,sizeof vis);
		for(int i=0;i<xx;i++)
		{
			for(int j=0;j<yy;j++)
			{
				cin>>c[i][j];
				if(c[i][j]=='@')
				{
					x11=i;
					y11=j;
				}
			}
		}
		DFS(x11,y11);
		cout<<ans<<endl;
	}
	return 0;
}

传送门：Oil Deposits HDU - 1241

还是用了个老方法，把走过的变成‘*’，还可以再开一个数组进行标记。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int xx,yy,x11,y11,ans;
char c[110][110];
int vis[110][110];
int dd[8][2]={1,0,-1,0,0,1,0,-1,1,1,-1,-1,1,-1,-1,1};
void DFS(int x,int y)
{
	c[x][y]='*';
	for(int i=0;i<8;i++)
	{
		int dx=x+dd[i][0];
        int dy=y+dd[i][1];
        if(dx>=0&&dy>=0&&dx<xx&&dy<yy&&c[dx][dy]!='*')  //不走出边界
        {
        	DFS(dx,dy);
		}
	}
}
int main()
{
	while(~scanf("%d %d",&xx,&yy)&&yy&&xx)
	{
		ans=0;
		for(int i=0;i<xx;i++)
			cin>>c[i];
		for(int i=0;i<xx;i++)
		{
        	for(int j=0;j<yy;j++)
       		{
       			if(c[i][j]=='@')
       			{
				   DFS(i,j);
				   ans++;
				}
			}
		}
		cout<<ans<<endl;
	}
	return 0;
	
}

传送门：Fox And Two Dots CodeForces - 510B （涉及到新方法）

//#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long int ll;
int xx,yy,flag;
int vis[55][55];
char map[55][55];
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};

void dfs(int a,int b,int aa,int bb)
{
	int k;
	char c=map[a][b];
	for(int k=0;k<4;k++)
	{
		int x=a+dx[k];
		int y=b+dy[k];
		if(map[x][y]==c&&x>=0&&y>=0&&x<xx&&y<yy)
		{
			if(x==aa&&y==bb) //因为是4个方向都要遍历，防止遍历时又退回上一步
				continue;
			if(vis[x][y])
			{
				flag=1;
				return ;
			}
			vis[x][y]=1;
			dfs(x,y,a,b);	
		}
	}
	
}
int main()
{
	while(~scanf("%d%d",&xx,&yy))
	{
	
		flag=0;
		memset(vis,0,sizeof vis);
		for(int i=0;i<xx;i++)
			cin>>map[i];
		for(int i=0;i<xx;i++)
		{
			for(int j=0;j<yy;j++)
			{
				if(!vis[i][j])
					dfs(i,j,-1,-1);
				if(flag)
					break;
			}
		}
		if (flag)
			printf ("Yes\n");
		else
			printf ("No\n");
	}	
    return 0;
}

N皇后问题 HDU - 2553 （超级经典，一定要好好感受里面的回溯思想）

当初不会这个题，然后就让N=4，然后就一直手跑2个多小时，最后终于跑出来了。。。

#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int N,cot;    //分别代表棋盘尺寸（皇后数量）和皇后可能成功摆放的结果总数
int size[11];//数组的下标表示行，对应的值表示列
int ans[11]; // 用于打表存放结果
void dfs(int n)
{
    int flag;
    if(n==N+1)  //当 最后一个皇后成功放置时返回.
    {
        cot++;   //成功的次数加一
        return ;
    }
    for(int i=1;i<=N;i++)
    {
        size[n]=i;   //代表将第一个皇后放置在第1行第i列（或者说第n个皇后）
        flag=1;      //放完之后就行标记
        for(int j=1;j<n;j++)  //这个for循环用来检测 这个皇后的位置和之前的n个皇后的位置是否冲突
        {
            if(size[j]==i||((abs(n-j))==abs(size[j]-i)))  //判断条件
            {
                flag=0;
                break;
            }
        }
        if(flag)
			dfs(n+1);   // 如果放置在第i列不冲突 则开始放下一个皇后   如果冲突 放在下一列继续判断
    }

}
int main()
{
    for( N=1;N<=11;N++)//因为本题时间限制，所以需要先打表
    {
        cot=0;    //临时存放结果
        dfs(1);
        ans[N]=cot;  // 将结果依次放入表中
    }
    while(cin >>N)
    {
        if(!N) break;
        cout <<ans[N]<<endl;
    }
    return 0;
}

传送门：Tempter of the Bone HDU - 1010 （奇偶剪枝）

大体的题意就不说了，就是DFS+奇偶剪枝。在这个题里有一个很牛的方法：奇偶剪枝，不会这个基本做不出来这个题，这里就不给大家简绍了，大家直接百度，里面的大佬写的太好了。

#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int n,m,T,flag,ti;  //ti是步数
char c[10][10];
int vis[10][10];
int x_1,y_1,x2,y2;
int dd[4][2]={-1,0,1,0,0,1,0,-1};
void dfs(int x,int y)
{
	if(x<0||y<0||x>=m||y>=n||ti>T)
		return ;                   //超出范围或者步数超了直接就剪掉
	if(flag)
		return ;                   //找到答案就剪掉
	if(x==x2&&y==y2&&ti==T)        //出口的判断
	{
		flag=1;
		return ;
	}
	int dis=abs(T-ti-(abs(x2-x)+abs(y2-y)));   //传说中的奇偶剪枝
	if(dis<0||dis%2)                            //我也是第一次用，感觉好厉害
		return ;
	vis[x][y]=1;
	for(int i=0;i<4;i++)
	{
		int dx=x+dd[i][0];
		int dy=y+dd[i][1];
		if(dx>=0&&dy>=0&&dx<m&&dy<n&&!vis[dx][dy]&&c[dx][dy]!='X')
		{
			ti++;
			dfs(dx,dy);
			vis[dx][dy]=0;              //回溯思想
			ti--;
			
		}
	}
	
}

int main()
{
	ios::sync_with_stdio(false);
	while(cin>>n>>m>>T)
	{
		ti=0;
		flag=0;
		memset(vis,0,sizeof vis);
		if(n==0&&m==0&&T==0) 
			break;
		for(int i=0;i<m;i++)
		{
			for(int j=0;j<n;j++)
			{
				cin>>c[i][j];
				if(c[i][j]=='S')
				{
					x_1=i;
					y_1=j;
				}
				if(c[i][j]=='D')
				{
					x2=i;
					y2=j;
				}
			}
		}
		dfs(x_1,y_1);
		if(flag)
			cout<<"YES"<<endl;
		else
			cout<<"NO"<<endl;
	}
    return 0;
}

传送门：棋盘问题 POJ - 1321

上面那么难的问题都解决了，这个一定会。

//#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long int ll;
int n,k,m,sum;
char c[10][10];
int vis[10][10];
int a[10];

void dfs(int cur)
{
	if(k==m)
	{
		sum++;
		return ;
	}
	if(cur>=n)
		return ;
	for(int j=0;j<n;j++)
	{
		if(a[j]==0&&c[cur][j]=='#')
		{
			a[j]=1;
			m++;
			dfs(cur+1);
			a[j]=0;
			m--;
		}
	}
	dfs(cur+1)；
}

int main()
{
	while(scanf("%d%d",&n,&k)&&n!=-1&&k!=-1)
	{
		sum=0;
		memset(a,0,sizeof a);
		for(int i=0;i<n;i++)
			cin>>c[i];
		dfs(0);
		cout<<sum<<endl;	
	}
	return 0;
}

传送门： Sudoku POJ - 2676

我的天哪，难死了，写了好长时间一直不对。。。
给一个CV代码，大家慢慢理解吧，。。。。

这道题的处理方式很巧妙。dfs中的参数只设置一个n(n就是代表着这是第几个数)就够了，就是当前的位置，在dfs中每次加一，如果当前位置不为0，就直接查找下一个位置。否则就从1～9中选一个数放进去，看同一行同一列以及同一小方格的同一行同一列有没有与之相同的，如果没有，就将当前位置的数更新成这个没有重复出现过的数。知道查找到n>=81的时候，即每个位置都查找完了，结束查找输出即可。注意在查找的过程中需要用到回溯，因为如果这一条路行不通而返回上一条路的时候，此时当前位置还应该是0.
n/9代表的就是当前位置的行，n%9代表的就是当前位置的列。
n/9/33表示的就是当前位置在小方格里的行，n%9/33代表的就是当前位置在小方格里的列。

#include<iostream>
#include<cstdio>
using namespace std;
int a[10][10],flag;
//    n/9代表的就是当前位置的行，n%9代表的就是当前位置的列。
//    n/9/3*3表示的就是当前位置在小方格里的行.
//   n%9/3*3代表的就是当前位置在小方格里的列。
bool check(int n,int now)    
{
    for(int i=0;i<9;i++)
    {
        int j=n%9;
        if(a[i][j]==now)
            return 0;
    }
    for(int j=0;j<9;j++)
    {
        int i=n/9;
        if(a[i][j]==now)
            return 0;
    }
    int di=n/9/3*3;
    int dj=n%9/3*3;
    for(int i =di;i<di+3;i++)
    {
        for(int j=dj;j<dj+3;j++)
        {
            if(a[i][j]==now)    return 0;
        }
    }
    return 1;
}
int dfs(int n)
{
    if(n>=81)
    {
        flag=1;
        return 0;
    }
    if(a[n/9][n%9]!=0)    dfs(n+1);
    else
    {
        for(int i=1;i<=9;i++)
        {
            if(check(n,i)==1)
            {
                a[n/9][n%9]=i;
                dfs(n+1);
                if(flag==1)
                    return 0;
                a[n/9][n%9]=0;//回溯
            }
        }        
    }
//    cout<<"?"<<endl;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        flag=0;
        for(int i=0;i<9;i++)
            for(int j=0;j<9;j++)
            scanf("%1d",&a[i][j]);  //一个贼有意思的输入 
        dfs(0);
        for(int i=0;i<9;i++)
        {
            for(int j=0;j<9;j++)
                printf("%d",a[i][j]);
            puts("");
        }
    }
    return 0;
}
林林亓
关注
专栏目录
Java实现dfs
aqimengxiangyu的博客
08-23 2045
DFS 的JAVA 实现dfs全排列全排列扩展问题迷宫最短路径问题 dfs 深度优先算法：优先考虑深度，一条路走到黑，直至无路可走 全排列 利用dfs实现全排列 public class Solution { static int n = 4; static int[] a = new int[n+1]; static int[] book = new int[n+1]; static void dfs(int step){ if(step == n+1){ for
DFS原理白话解析
菜鸟算法
11-04 7万+
前言 看了许多的关于dfs的博客，自己也研究了好多遍，最终算是入门了，下面就简单的个人理解的原理以及结合一个简单的全排列实例进行讲解。 原理简介 dfs基于递归思想，递归思想就是把一个事拆分成若干见相同的小事共同组合完成，具体见下图的斐波那契的图文解决 这就是一个最典型的递归，入口f(5)出口就是每次递归的return； 说完递归就是dfs，其有两个重要的标志，也就是两个数组，一个用来标记该点是...
DFS 树
malanlllll的的的的的博客
03-27 1万+
翻译自 THe DFS tree and its applications: how I found out I really didn’t understand bridges 介绍 这是一篇对可以用图的 DFS 树来解的题的教程/扩展。 在很长一段时间，我并没有真正理解传统算法是如何找到桥的。很多题解看起来没有真正解释它是如何工作的，很多只是顺带提到它但后迅速地进入实现部分。某一天有人解释了 ...
DFS概念介绍
fhaoi的博客
06-27 8685
深度优先遍历（Depth First Search, 简称 DFS） 与广度优先遍历（Breath First Search）是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻路（走迷宫），搜索引擎，爬虫等，也频繁出现在 leetcode，高频面试题中。 本文将会从以下几个方面来讲述深度优先遍历，广度优先遍历，相信大家看了肯定会有收获。 深度优先遍历，广度优先遍历简介 习题演练 DFS，BFS 在搜索引擎中的应用 深度优先遍历简介 1、深度优先遍历 深度优先遍历主要思路是从图中一个未访问的顶点 V
DFS(深度优先搜索算法)
热门推荐
无限迭代中......
12-04 22万+
基本概念 深度优先搜索算法（Depth First Search，简称DFS）：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。 算法思想 回溯法（探索与回溯法...
DFS入门级（模板）
浮生未歇
08-16 10万+
DFS 最近一直都在写蓝桥杯的题目，其中有许多题目涉及到了搜索（DFS，BFS）等，由于递归过于抽象，所以没能很好的掌握。于是便写下了这篇入门教程来加深对DFS的认识，并且充分理解递归。 所谓DFS就是指：优先考虑深度，换句话说就是一条路走到黑，直到无路可走的情况下，才会选择回头，然后重新选择一条路。 1.全排列（入门引导） 引导题：输入一个数n，输出n的全排列 可以先把这个问题形象化 如： 假如有编号为1,2,3的3张扑克牌和编号为1,2,3的3个盒子。将这3张扑克牌分别放入3个盒子一共有几种不同的放
DFS 解题套路
努力中的老周的专栏
03-17 2070
DFS 解题套路 如果碰到一个 DFS 题目，基本的代码套路如下： 1、我们基本都是使用递归来解决 DFS 问题，因此要确定递归的结束条件，也就是 DFS 结束条件。 2、写 DFS 函数套路框架。如下所示 void dfs() { } int main() { 读入数据 dfs(); return 0; } 3、确认 DFS 函数的参数。这个是最难的地方...
C++算法——DFS
MrChen666的博客
11-14 1万+
DFS我们称之为深搜，通常解决一些最大最长或者所有可能的问题，一般用递归来实现。因为深搜基本上会遍历每一个结果，但暴力法不同在于，深搜可以通过递归中不满足条件，实现剪枝。 我们先来看一道例题，感受一下深搜。 思路其实比较简单，有点类似于穷举法。我们构建一棵数，每一层依次增加一个没有枚举的数，当到达底层的时候就是一个答案。 比如我们先将第一个数填1，然后由于还有数未填入，继续深入到达下一层。下一层由于第一个数1已经枚举，我们枚举第二个数2。然后继续进入第三层，枚举第三个数3，由于已经把所有的数都枚举完，我
DFS 序总结
ZhuRanCheng的博客
05-21 1060
DFS 序总结
DFS时间复杂度
liuxiaocs7的博客
04-06 2万+
DFS算法是一一个递归算法，需要借助一个递归工作栈，故它的空间复杂度为O(N)O(N)O(N)。 遍历图的过程实质上是对每个顶点查找其邻接点的过程，其耗费的时间取决于所采用结构。 邻接表表示时，查找所有顶点的邻接点所需时间为O(E)O(E)O(E)，访问顶点的邻接点所花时间为O(N)O(N)O(N),此时，总的时间复杂度为O(N+E)O(N+E)O(N+E)。 邻接矩阵表示时，查找每个顶点的邻接...
dfs_C++_dfs_
09-30
DFS，全称深度优先搜索（Depth First Search），是一种在图或树中遍历所有节点的算法。在C++中实现DFS，通常会涉及到递归或栈这两种数据结构。本资料包含了一个C++实现DFS的源代码示例，适用于初学者理解和学习如何...
DFS.rar_DFS algorithm_dfs_dfs python
09-20
深度优先搜索（DFS，Depth-First Search）是一种用于遍历或搜索树或图的算法。在计算机科学中，它常用于解决各种问题，包括寻找路径、判断连通性以及求解最短路径等。DFS的基本策略是尽可能深地探索树的分支，直到...
Windows server 2019系统配置DFS文件服务器SOP
最新发布
05-28
### Windows Server 2019 DFS文件服务器配置详解 #### 一、DFS文件服务器核心原理与功能 **1.1 DFS文件服务器简介** DFS（Distributed File System）是一种分布式文件系统，它允许用户通过单一的逻辑命名空间来...
dfs.rar_dfs_dfs java
09-19
深度优先搜索（DFS，Depth-First Search）是一种用于遍历或搜索树或图的算法。在Java编程中，DFS常用于解决各种问题，如图的遍历、迷宫求解、拓扑排序等。DFS的基本思想是从根节点开始，沿着某一分支深入到尽可能深...
Windows Server 2019 文件同步配置教程DFS文件服务器
02-21
Windows Server 2019 文件同步配置教程DFS文件服务器主要涉及的是如何在Windows Server环境中实现文件的高效同步和高可用性。DFS（Distributed File System）是微软提供的一种分布式文件系统，它允许用户通过单一的...
双向队列（dequeue）的基本操作
个人学习的一些笔记
01-16 3622
基本操作如下，前面加一个【名称.操作】，eg：deq.pop_back（）；
Educational Codeforces Round 82 (Rated for Div. 2)（A~D）
个人学习的一些笔记
02-13 2491
唉，有点可惜，感觉D题能做出来，可惜时间有点不够了… 先写三个题的题解吧，剩下的慢慢补。 A. Erasing Zeroes A就没什么好说的了，统计出最左和最右的位置看一下中间有多少0就行。 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int maxn=100010,mod=1e9+...
矩阵计算器+求线性代数n阶行列式代码
个人学习的一些笔记
03-01 1525
算的实在是心烦，上网找了一篇大佬的代码 真的是牛逼，附：大佬博客 #include <malloc.h> #include <stdio.h> #include <stdlib.h>//包含的头文件不解释 #define bool int //因为标准c里边没有bool类型才这么做 #define false 0 #define true 1 //定义...
拓展：优先队列+pair+二维map（6）
个人学习的一些笔记
09-04 592
优先队列 本来打算自己写的，但是有人已经写了，所以大家直接看这篇吧！ 看这里，点这里 优先队列在稍微高级的题里面基本都会用到，所以建议读者认真学。 pair 看这里，点这里 pair的基本用法得会，虽然现在还用不到，其实也能用到，就像STL容器里的map和pair。更重要的是，在以后图论的存图中，pair会频繁的用到，所以读者还是得好好学。 ...
dfs
06-01
DFS（Depth First Search，深度优先搜索）是一种搜索算法，用于在树或图等数据结构中遍历所有节点。DFS 从起始节点开始，沿着一条路径一直遍历到底，直到不能再前进为止，然后返回上一个节点，继续遍历其它路径。DFS...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值