每天学一点算法-DFS

最新推荐文章于 2023-06-07 17:08:11 发布
最新推荐文章于 2023-06-07 17:08:11 发布
阅读量1.6k 收藏 3
点赞数
分类专栏： 基础知识学习 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itfootball/article/details/41594027
版权

DFS


深度优先算法


定义


深度优先搜索算法（Depth-First-Search），是搜索算法的一种。它沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。DFS 属于盲目搜索。

　　深度优先搜索是图论中的经典算法，利用深度优先搜索算法可以产生目标图的相应拓扑排序表，利用拓扑排序表可以方便的解决很多相关的图论问题，如最大路径问题等等。一般用堆数据结构来辅助实现 DFS 算法。


步骤


1.访问顶点v；

2.  依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；

3.  若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。

上述描述可能比较抽象，举个实例：

　　DFS 在访问图中某一起始顶点 v 后，由 v 出发，访问它的任一邻接顶点 w1；再从 w1 出发，访问与 w1 邻 接但还没有访问过的顶点 w2；然后再从 w2 出发，进行类似的访问，… 如此进行下去，直至到达所有的邻接顶点都被访问过的顶点 u 为止。

　　接着，退回一步，退到前一次刚访问过的顶点，看是否还有其它没有被访问的邻接顶点。如果有，则访问此顶点，之后再从此顶点出发，进行与前述类似的访问；如果没有，就再退回一步进行搜索。重复上述过程，直到连通图中所有顶点都被访问过为止。


使用于找出一条走出迷宫的路问题。


时间复杂度


当用二维数组表示邻接矩阵作图的存储结构时，查找每个顶点的邻接点所需时间为

O(n^2),

其中n为顶点数．

而当以邻接表作图的存储结构时，找邻接点所需时间为O(e),其中e为无向图中边的数或有向图中弧的数。

由此，当以邻接表作存储结构时，深度优先搜索遍历图的时间复杂度为

O(n+e).



代码


有向图






public class DFS {

	static Map<Integer, String> points = new HashMap<Integer, String>();

	static {
		points.put(0, "A");
		points.put(1, "B");
		points.put(2, "C");
		points.put(3, "D");
		points.put(4, "E");

	}

	public static void main(String[] args) {
		// 邻接矩阵表示图的存储结构
		int[][] datas = { { min, 1, 2, max, max },// A点到其他点的距离
				{ max, min, max, max, 5 },// B点到其他点的距离
				{ max, 4, min, 7, max },// C点到其他点的距离
				{ max, 6, max, min, max },// D点到其他点的距离
				{ 3, max, 8, max, min } // E点到其他点的距离
		};
		DFS dfs = new DFS();
		Scanner scanner = new Scanner(System.in);
		while (true) {
			System.out.println("请输入起始点: ");
			Integer index = scanner.nextInt();
			System.out.println(points.get(index) + "点到各条有效路径长分别为 : ");
			dfs.traverse_DFS(datas, index);
		}

	}

	// 自己与自己的距离
	static int min = 0;
	// 没有有向图的节点之间的距离
	static int max = Integer.MAX_VALUE;
	private static int[][] arcs;
	// 保存已遍历的节点,索引代表节点号,值代表是否已被所遍历
	private static boolean[] hasVisit;

	private void traverse_DFS(int[][] datas, int begin) {
		if (datas == null || datas.length == 0
				|| datas[0].length != datas.length) {
			System.out.println("邻接矩阵有问题,退出！");
			return;
		}
		arcs = datas;
		hasVisit = new boolean[datas.length];
		for (int i = 0; i < datas.length; i++) {
			hasVisit[i] = false;
		}
		recur_DFS(begin);
		{
			sum();
		}
	}

	static List<Integer> path = new ArrayList<Integer>();

	private void recur_DFS(int begin) {
		hasVisit[begin] = true;
		System.out.println("添加顶点: " + points.get(begin));
		path.add(begin);
		if (begin == 0) {
			System.out.println("start");
		}
		for (int i = 0; i < arcs.length; i++) {
			int num = arcs[begin][i];
			boolean flag = hasVisit[i];
			if (min != num && max != num && !flag) {
				recur_DFS(i);
			}
		}
	}

	private int sum() {
		System.out.println("=================start=======================");
		int sum = 0;
		for (int i = 0; i < path.size(); i++) {
			System.out.println("经过顶点 : " + points.get(path.get(i)));
			if (i > 0) {
				System.out.println("顶点" + points.get(path.get(i - 1)) + "与顶点"
						+ points.get(path.get(i)) + "的距离为 : "
						+ arcs[path.get(i - 1)][path.get(i)]);
				if (arcs[path.get(i - 1)][path.get(i)] == max
						|| arcs[path.get(i - 1)][path.get(i)] == min) {
					System.out.println("无法遍历所有顶点,该方法不可行");
					path.clear();
					return 0;
				}
				sum += arcs[path.get(i - 1)][path.get(i)];
			}
		}
		if (sum != 0)
			System.out.println("路线的权值和为 : " + sum);
		System.out.println("========================================");
		path.clear();
		return sum;
	}
}



请输入起始点: 
2
C点到各条有效路径长分别为 : 
添加顶点: C
添加顶点: B
添加顶点: E
添加顶点: A
start
添加顶点: D
=================start=======================
经过顶点 : C
经过顶点 : B
顶点C与顶点B的距离为 : 4
经过顶点 : E
顶点B与顶点E的距离为 : 5
经过顶点 : A
顶点E与顶点A的距离为 : 3
经过顶点 : D
顶点A与顶点D的距离为 : 2147483647
无法遍历所有顶点,该方法不可行
请输入起始点: 
1
B点到各条有效路径长分别为 : 
添加顶点: B
添加顶点: E
添加顶点: A
start
添加顶点: C
添加顶点: D
=================start=======================
经过顶点 : B
经过顶点 : E
顶点B与顶点E的距离为 : 5
经过顶点 : A
顶点E与顶点A的距离为 : 3
经过顶点 : C
顶点A与顶点C的距离为 : 2
经过顶点 : D
顶点C与顶点D的距离为 : 7
路线的权值和为 : 17
========================================
请输入起始点: 
0
A点到各条有效路径长分别为 : 
添加顶点: A
start
添加顶点: B
添加顶点: E
添加顶点: C
添加顶点: D
=================start=======================
经过顶点 : A
经过顶点 : B
顶点A与顶点B的距离为 : 1
经过顶点 : E
顶点B与顶点E的距离为 : 5
经过顶点 : C
顶点E与顶点C的距离为 : 8
经过顶点 : D
顶点C与顶点D的距离为 : 7
路线的权值和为 : 21
========================================
请输入起始点:


无向无权图





public class DFS2 {
	static Map<Integer, String> points = new HashMap<Integer, String>();

	static {
		points.put(0, "A");
		points.put(1, "B");
		points.put(2, "C");
		points.put(3, "D");
		points.put(4, "E");
		points.put(5, "F");
		points.put(6, "G");
		points.put(7, "H");
		points.put(8, "I");

	}
	boolean[] hasVisits;
	int[][] arcs;

	public void search(int[][] args) throws InterruptedException {
		if (args == null || args.length == 0 || args.length != args[0].length) {
			System.out.println("邻接矩阵有问题,退出");
			return;
		}
		arcs = args;
		hasVisits = new boolean[args.length];
		for (int j = 0; j < args.length; j++) {
			hasVisits[j] = false;
		}
		for (int i = 0; i < args.length; i++) {
			System.out.println("============ " + points.get(i));
			if (!hasVisits[i])
				recur_DFS(i);
		}
	}

	private void recur_DFS(int begin) {
		hasVisits[begin] = true;
		System.out.println("经过顶点 : " + points.get(begin));
		for (int i = 0; i < arcs.length; i++) {
			if (arcs[begin][i] == 1 && !hasVisits[i])
				recur_DFS(i);
		}
	}

	public static void main(String[] args) {
		DFS2 dfs2 = new DFS2();
		// 无向图,无权值,用邻接矩阵表示如下
		int[][] datas = { { 0, 1, 0, 0, 0, 1, 0, 0, 0 },// A点矩阵
				{ 1, 0, 1, 0, 0, 0, 1, 0, 1 },// B点矩阵
				{ 0, 1, 0, 1, 0, 0, 0, 0, 1 },// C点矩阵
				{ 0, 0, 1, 0, 1, 0, 1, 1, 1 },// D点矩阵
				{ 0, 0, 0, 1, 0, 1, 0, 1, 0 },// E点矩阵
				{ 1, 0, 0, 0, 1, 0, 1, 0, 0 },// F点矩阵
				{ 0, 1, 0, 1, 0, 1, 0, 1, 0 },// G点矩阵
				{ 0, 0, 0, 1, 1, 0, 1, 0, 0 },// H点矩阵
				{ 0, 1, 1, 1, 0, 0, 0, 0, 0 },// I点矩阵
		};
		try {
			dfs2.search(datas);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}


输出


============ A
经过顶点 : A
经过顶点 : B
经过顶点 : C
经过顶点 : D
经过顶点 : E
经过顶点 : F
经过顶点 : G
经过顶点 : H
经过顶点 : I
============ B
经过顶点 : B
经过顶点 : A
经过顶点 : F
经过顶点 : E
经过顶点 : D
经过顶点 : C
经过顶点 : I
经过顶点 : G
经过顶点 : H
============ C
经过顶点 : C
经过顶点 : B
经过顶点 : A
经过顶点 : F
经过顶点 : E
经过顶点 : D
经过顶点 : G
经过顶点 : H
经过顶点 : I
============ D
经过顶点 : D
经过顶点 : C
经过顶点 : B
经过顶点 : A
经过顶点 : F
经过顶点 : E
经过顶点 : H
经过顶点 : G
经过顶点 : I
============ E
经过顶点 : E
经过顶点 : D
经过顶点 : C
经过顶点 : B
经过顶点 : A
经过顶点 : F
经过顶点 : G
经过顶点 : H
经过顶点 : I
============ F
经过顶点 : F
经过顶点 : A
经过顶点 : B
经过顶点 : C
经过顶点 : D
经过顶点 : E
经过顶点 : H
经过顶点 : G
经过顶点 : I
============ G
经过顶点 : G
经过顶点 : B
经过顶点 : A
经过顶点 : F
经过顶点 : E
经过顶点 : D
经过顶点 : C
经过顶点 : I
经过顶点 : H
============ H
经过顶点 : H
经过顶点 : D
经过顶点 : C
经过顶点 : B
经过顶点 : A
经过顶点 : F
经过顶点 : E
经过顶点 : G
经过顶点 : I
============ I
经过顶点 : I
经过顶点 : B
经过顶点 : A
经过顶点 : F
经过顶点 : E
经过顶点 : D
经过顶点 : C
经过顶点 : G
经过顶点 : H

Q博士
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LearnAlgorithm:每天学习算法
03-19
学习算法 每天学习算法。 ** 2021-03-17 **问题：有重复字符串的分隔组合。（编写一种方法，计算某字符串的所有分隔组合。） ** 2021-03-18 **问题：发现复制中重复的数字。（在一个长度为n的分布nums里的所有数字都在0〜n-1的范围内。多个中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了一次。
每天学一点算法-快速排序算法
doctorq
11-25 1256
搞了一上午搞了个程序，勉强通过，先保存下来，以后再优化。
[100天每天一个算法--第1天] 背包算法
热门推荐
抬山的博客
08-12 1万+
其实PHP程序员需不需要学算法，要不要深挖算法，一直没个定论。博主本人准大四，在找实习的过程中逐渐发现学习算法的重要性，博主以前在学校的工作室老大说过一句话，熟悉算法，可以让你的天花板更高一些，所以便有了这个博客系列，每天一个算法来由简到难逐步提升自己的编程能力。 今天博主想讲一下背包算法.。 由一道题开始，情景如下: 0-1背包问题： n个物品和1个背包，每个物品i对应的重量为...
每天一个算法（简单）
hands_up_down的博客
09-14 1340
此篇文章的目的是在于建立一个可以协同配合的工作流，我希望对于一个算法的理解包含以下内容：详尽的分析，程序的结构，代码。文章中包含前两个部分，然后在本地完成代码。编写代码是否需要再附上结构，很难说，我现在想的是只加上主干，再附上一个链接即可对于一个大数，直接处理往往是很复杂的。通常，使用因式分解对大数进行拆分，对每一个质因数进行处理自然数通常可以写成质因数相乘的形式模式识别：需要移动左右两头的问题可以考虑双指针题目：给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。
Leetcode 11. 盛最多水的容器
予早说技术
02-26 141
给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 说明：你不能倾斜容器。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/container-with-most-water 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处..
matlab广度优先算法代码-Search-Algorithms-BFS-DFS-A-:搜索算法-BFS-DFS-A-
05-24
matlab广度优先算法代码搜索算法-BFS-DFS-A-star 搜索是AI中解决问题的通用技术。 这个项目将使您开始使用这些不同的算法： 蛮力搜索策略 广度优先搜索：它从根节点开始，先探索相邻节点，然后再向下一级邻居移动。 ...
ACM算法设计-BFS-DFS详解_算法_dfs_ACM_zoouts_bfs_
10-01
对bfs（广度优先遍历）和dfs（深度优先遍历）的详细解析，帮助人们理解广搜和深搜
basicworld#py_structure#chap7.2_图的基本遍历算法--DFS和BFS（python版）1
07-25
注意遍历的结果可能不止一种深度优先DFS深度优先遍历得到的顶点序列为深度优先搜索序列（DFS序列）访问顶点v，并记录为已访问检查v的邻接点，选择尚未访问的点，不
图形学-种子填充算法-C++
03-27
图形学-种子填充算法-C++
计算机图形学实验de-Casteljau算法知识讲解.docx
03-29
计算机图形学实验de-Casteljau算法知识讲解.docx计算机图形学实验de-Casteljau算法知识讲解.docx计算机图形学实验de-Casteljau算法知识讲解.docx计算机图形学实验de-Casteljau算法知识讲解.docx计算机图形学实验de-...
Floyd算法求任意两点间的最短距离+BFS+DFS
08-08
用邻接矩阵来存储图，Floyed算法求任意两点间的最短路径并输出，广度优先遍历，深度优先遍历
每天学算法
fengleqi的博客
05-30 221
归并排序算法       它是一种基于比较的排序算法，使用分治法解决那些原本复杂度为O(N^2)的问题。傅立叶变换与快速傅立叶变换        互联网、你的WIFI、智能手机、电话、计算机、路由器、卫星，几乎所有内置计算机的东西都会以各种方式使用这些算法实现各自的功能。如果你没有学习这些重要的算法，你将无法获得电子、计算机或通信方面的学位dijksrtra 算法        这是一种图搜索算法...
每天学习算法二
a124759779的博客
08-28 89
冒泡排序法 冒泡排序法的核心思想：每次比较相邻的两个数，如果他们的顺序错误就把他们交换过来，越小的越靠后。主要使用双循环实现算法。 例如现在输入10个数，分别是8 100 50 22 15 6 1 1000 999 0 第一次比较第一位和第二位数，若错误，则交换位置，第二次比较第二位和第三位数，若错误则交换顺序。。。。。。。（直到比较完所有的数） 正确的运行结果为：0 1 6 8 ...
每天学习一个算法
qq_42184753的博客
11-02 196
每天学习一个算法 1、二分法查找 算法是什么： 如何用最省内存的方式实现快速查找功能 算法如下: 1.确定查找范围front=0，end=N-1，计算中项mid=（front+end）/2。 2.若a[mid]=x或front>=end,则结束查找；否则，向下继续。 3.若a[mid]<x,说明待查找的元素值只可能在比中项元素大的范围内，则把mid+1的值赋给front，并重新计算mid，转去执行步骤2；若a[mid]>x，说明待查找的元素值只可能在比中项元素小的范围内，则把mid-1
深度优先搜索(DFS)算法
最新发布
beenles的博客
06-07 4170
深度优先搜索算法（DFS）是一种用于遍历图形结构的算法，它从一个起始顶点开始，沿着一条路径尽可能深入地访问图中的所有顶点，直到不能继续为止，然后返回并探索其他路径。DFS算法使用栈数据结构来实现，在访问完一个顶点后，将其未被访问的邻居压入栈中，并标记为已访问，然后从栈中取出下一个未被访问的顶点，继续进行同样的操作，直到栈为空为止。DFS算法可以用于解决图中的许多问题，例如找出两个顶点之间的最短路径、判断图是否为连通图等。DFS算法的时间复杂度为O(V+E)，其中V为顶点数，E为边数。DFS算法相比BFS算法
每天学习算法 一
a124759779的博客
08-25 152
从今天开始每天学习两种算法 第一天学习的是《啊哈！算法》 是一本通俗易懂的算法书籍 算法一：简易桶排序 核心思想：创建数组，使用数组对数值进行排序，例如数值100以内排序，首先创建一个数组 数组含101个值 0~100 例如 int a[101] ，（数组里面的值就是我们的“桶”了）然后利用循环，把对应的值给到对应的桶里，例如5就放在数组 a[5]里面，有一个5的值桶的...
每天学习一个算法--冒泡排序
weixin_37596689的博客
12-21 467
冒泡排序： 顾名思义，比如水池里有10个气泡，由下至上的两两比较，较大的就上升一位，直到浮出水面。
每天学习一算法系列（19）(输入n，用最快的方法求该数列的第n 项)
yuucyf的专栏
07-22 3437
题目： 定义Fibonacci 数列如下： f(n)  = 0 (n=0) f(n)  = 1 (n=1, 2) f(n)  =  f(n-1)+f(n-2)  (n>2) 输入n，用最快的方法求该数列的第n 项。 思路一： 我相信很多程序员看到这道题都很容易想到用递归的方法解这个问题，但是，你知道的，这并不是最快的方法。还有一种方法就是用一个For(While)循环来遍历同样可
每天学一点算法-动态规划算法
doctorq
12-05 1309
动态规划算法 定义 动态规划（Dynamic programming）是一种在数学、计算机科学和经济学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。 动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。 　　动态规划背后的基本思想非常简单。大致上，若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问
图形学算法之Nicholl-Lee-Nicholl算法
06-06
Nicholl-Lee-Nicholl（NLN）算法是一种用于计算二次曲面和直线之间的交点的图形学算法。它是一种基于解方程的方法，通过求解二次方程组来计算交点。NLN算法可以用于实现许多图形学应用程序，例如计算三维物体表面的交点和投影点，以及计算光线和物体表面的交点等。 NLN算法的基本思想是将一条直线的参数方程代入二次曲面方程，然后解出二次方程组，从而得到直线和曲面的交点。具体来说，假设直线的参数方程为P(u) = P0 + u * V，其中P0是直线上的一点，V是直线的方向向量，u是参数，二次曲面的方程为Q(x,y,z) = Ax^2 + By^2 + Cz^2 + Dxy + Exz + Fyz + Gx + Hy + Iz + J = 0，其中A、B、C、D、E、F、G、H、I、J是常数。将直线的参数方程代入二次曲面方程，得到一个一元二次方程关于参数u的方程，解出u，然后代入直线的参数方程，即可求出交点P(u)。 NLN算法的优点是计算速度快，不需要进行迭代计算，精度高，并且可以处理各种类型的曲面和直线。缺点是在某些情况下可能会出现计算不稳定的情况，例如当直线与二次曲面的交点非常靠近曲面的某些奇点时。此外，NLN算法需要解二次方程组，因此对于一些复杂的曲面，计算量可能会很大。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值