求无向无权图起点到终点的所有路径

最新推荐文章于 2023-05-22 12:48:54 发布
最新推荐文章于 2023-05-22 12:48:54 发布
阅读量7.5k 收藏 8
点赞数 2
分类专栏： Algorithm(算法) 文章标签： 图 所有路径 起点到终点 起点到终点的所有路径
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/collonn/article/details/18222723
版权

求无向无权图起点到终点的所有路径


基本思路：

基于图的深度优先遍历进行修改。

0：初始栈中只有起点元素。

步骤1：如果栈为空，则返回，否则，访问栈顶节点，但先不删除栈顶元素。

步骤2：如果该元素的邻接点

(1)是终点，则打印路径。

(2)在栈中已存在，则是环路，不处理。

(2)正常，则将该邻接点入栈，继续步骤1


示例图如下：



代码如下：

package com.collonn.algorithm.grf;

import java.util.Stack;

/**
 * 无向无权无环图<br/>
 * 寻找起点到终点的所有路径
 */
public class GrfAllEdge {
	// 图的顶点总数
	private int total;
	// 各顶点基本信息
	private String[] nodes;
	// 图的邻接矩阵
	private int[][] matirx;

	public GrfAllEdge(int total, String[] nodes) {
		this.total = total;
		this.nodes = nodes;
		this.matirx = new int[total][total];
	}

	private void printStack(Stack<Integer> stack, int k) {
		for (Integer i : stack) {
			System.out.print(this.nodes[i] + ",");
		}
		System.out.print(this.nodes[k] + ",");
	}

	/**
	 * 寻找起点到终点的所有路径
	 * 
	 * @param underTop
	 *            紧挨着栈顶的下边的元素
	 * @param goal
	 *            目标
	 * @param stack
	 */
	private void dfsStack(int underTop, int goal, Stack<Integer> stack) {
		// System.out.print("\n栈元素:");
		// this.printStack(stack);

		if (stack.isEmpty()) {
			return;
		}

		// 访问栈顶元素，但不弹出
		int k = stack.peek().intValue();
		// 紧挨着栈顶的下边的元素
		int uk = underTop;

		if (k == goal) {
			System.out.print("\n起点与终点不能相同");
			return;
		}

		// 对栈顶的邻接点依次递归调用，进行深度遍历
		for (int i = 0; i < this.total; i++) {
			// 有边，并且不在左上到右下的中心线上
			if (this.matirx[k][i] == 1 && k != i) {
				// 排除环路
				if (stack.contains(i)) {
					// 由某顶点A，深度访问其邻接点B时，由于是无向图，所以存在B到A的路径，在环路中，我们要排除这种情况
					// 严格的请，这种情况也是一个环
					if (i != uk) {
						System.out.print("\n有环:");
						this.printStack(stack, i);
					}
					continue;
				}

				// 打印路径
				if (i == goal) {
					System.out.print("\n路径:");
					this.printStack(stack, i);
					continue;
				}

				// 深度遍历
				stack.push(i);
				dfsStack(k, goal, stack);
			}
		}

		stack.pop();
	}

	private void printMatrix() {
		System.out.println("----------------- matrix -----------------");
		System.out.println("---0-1-2-3-4-5-6-7-8--");
		System.out.println("---A-B-C-D-E-F-G-H-I--");
		for (int i = 0; i < this.total; i++) {
			System.out.print(" " + this.nodes[i] + "|");
			for (int j = 0; j < this.total; j++) {
				System.out.print(this.matirx[i][j] + "-");
			}
			System.out.print("\n");
		}
		System.out.println("----------------- matrix -----------------");
	}

	// 设置[i][i]位置处的元素值为0，0表示图中的定点i未被访问，1表示图中的定点i已被访问
	private void resetVisited() {
		for (int i = 0; i < this.total; i++) {
			this.matirx[i][i] = 0;
		}
	}

	// 初始化图数据
	// 0---1---2---3---4---5---6---7---8---
	// A---B---C---D---E---F---G---H---I---
	private void initGrf() {
		// A-B, A-D, A-E
		this.matirx[0][1] = 1;
		this.matirx[1][0] = 1;
		this.matirx[0][3] = 1;
		this.matirx[3][0] = 1;
		this.matirx[0][4] = 1;
		this.matirx[4][0] = 1;
		// B-C
		this.matirx[1][2] = 1;
		this.matirx[2][1] = 1;
		// C-F
		this.matirx[2][5] = 1;
		this.matirx[5][2] = 1;
		// D-E, D-G
		this.matirx[3][4] = 1;
		this.matirx[4][3] = 1;
		this.matirx[3][6] = 1;
		this.matirx[6][3] = 1;
		// E-F, E-H
		this.matirx[4][5] = 1;
		this.matirx[5][4] = 1;
		this.matirx[4][7] = 1;
		this.matirx[7][4] = 1;
		// F-H, F-I
		this.matirx[5][7] = 1;
		this.matirx[7][5] = 1;
		this.matirx[5][8] = 1;
		this.matirx[8][5] = 1;
		// G-H
		this.matirx[6][7] = 1;
		this.matirx[7][6] = 1;
		// H-I
		this.matirx[7][8] = 1;
		this.matirx[8][7] = 1;
	}

	// 初始化图数据
	// 0---1---2---3---4---5---6---7---8---
	// A---B---C---D---E---F---G---H---I---
	private void initGrf2() {
		// A-B, A-D, A-E
		this.matirx[0][1] = 1;
		this.matirx[1][0] = 1;
		this.matirx[0][3] = 1;
		this.matirx[3][0] = 1;
		this.matirx[0][4] = 1;
		this.matirx[4][0] = 1;
		// B-C
		this.matirx[1][2] = 1;
		this.matirx[2][1] = 1;
		// C-F
		this.matirx[2][5] = 1;
		this.matirx[5][2] = 1;
		// D-E
		this.matirx[3][4] = 1;
		this.matirx[4][3] = 1;
		// E-F, E-H
		this.matirx[4][5] = 1;
		this.matirx[5][4] = 1;
		this.matirx[4][7] = 1;
		this.matirx[7][4] = 1;
		// F-H, F-I
		this.matirx[5][7] = 1;
		this.matirx[7][5] = 1;
		this.matirx[5][8] = 1;
		this.matirx[8][5] = 1;
		// G-H
		this.matirx[6][7] = 1;
		this.matirx[7][6] = 1;
		// H-I
		this.matirx[7][8] = 1;
		this.matirx[8][7] = 1;
	}

	// 初始化图数据
	// 0---1---2---3---4---5---6---7---8---
	// A---B---C---D---E---F---G---H---I---
	private void initGrf3() {
		// A-D, A-E
		this.matirx[0][3] = 1;
		this.matirx[3][0] = 1;
		this.matirx[0][4] = 1;
		this.matirx[4][0] = 1;
		// B-C
		this.matirx[1][2] = 1;
		this.matirx[2][1] = 1;
		// C-F
		this.matirx[2][5] = 1;
		this.matirx[5][2] = 1;
		// E-H, E-I
		this.matirx[4][7] = 1;
		this.matirx[7][4] = 1;
		this.matirx[4][8] = 1;
		this.matirx[8][4] = 1;
		// F-I
		this.matirx[5][8] = 1;
		this.matirx[8][5] = 1;
		// G-H
		this.matirx[6][7] = 1;
		this.matirx[7][6] = 1;
	}

	public static void main(String[] args) {
		String[] nodes = new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I" };
		GrfAllEdge grf = new GrfAllEdge(9, nodes);
		grf.initGrf();
		grf.printMatrix();

		System.out.print("\n------ 寻找起点到终点的所有路径开始 ------");
		grf.resetVisited();
		int origin = 0;
		int goal = 8;
		Stack<Integer> stack = new Stack<Integer>();
		stack.push(origin);
		grf.dfsStack(-1, goal, stack);
		System.out.print("\n------ 寻找起点到终点的所有路径结束 ------");
	}

}


第一个无向图的结果如下，输出环路和正确路径：

------ 寻找起点到终点的所有路径开始 ------
有环:A,B,C,F,E,A,
有环:A,B,C,F,E,D,A,
有环:A,B,C,F,E,D,G,H,E,
有环:A,B,C,F,E,D,G,H,F,
路径:A,B,C,F,E,D,G,H,I,
有环:A,B,C,F,E,H,F,
有环:A,B,C,F,E,H,G,D,A,
有环:A,B,C,F,E,H,G,D,E,
路径:A,B,C,F,E,H,I,
有环:A,B,C,F,H,E,A,
有环:A,B,C,F,H,E,D,A,
有环:A,B,C,F,H,E,D,G,H,
有环:A,B,C,F,H,E,F,
有环:A,B,C,F,H,G,D,A,
有环:A,B,C,F,H,G,D,E,A,
有环:A,B,C,F,H,G,D,E,F,
有环:A,B,C,F,H,G,D,E,H,
路径:A,B,C,F,H,I,
路径:A,B,C,F,I,
有环:A,D,E,A,
有环:A,D,E,F,C,B,A,
有环:A,D,E,F,H,E,
有环:A,D,E,F,H,G,D,
路径:A,D,E,F,H,I,
路径:A,D,E,F,I,
有环:A,D,E,H,F,C,B,A,
有环:A,D,E,H,F,E,
路径:A,D,E,H,F,I,
有环:A,D,E,H,G,D,
路径:A,D,E,H,I,
有环:A,D,G,H,E,A,
有环:A,D,G,H,E,D,
有环:A,D,G,H,E,F,C,B,A,
有环:A,D,G,H,E,F,H,
路径:A,D,G,H,E,F,I,
有环:A,D,G,H,F,C,B,A,
有环:A,D,G,H,F,E,A,
有环:A,D,G,H,F,E,D,
有环:A,D,G,H,F,E,H,
路径:A,D,G,H,F,I,
路径:A,D,G,H,I,
有环:A,E,D,A,
有环:A,E,D,G,H,E,
有环:A,E,D,G,H,F,C,B,A,
有环:A,E,D,G,H,F,E,
路径:A,E,D,G,H,F,I,
路径:A,E,D,G,H,I,
有环:A,E,F,C,B,A,
有环:A,E,F,H,E,
有环:A,E,F,H,G,D,A,
有环:A,E,F,H,G,D,E,
路径:A,E,F,H,I,
路径:A,E,F,I,
有环:A,E,H,F,C,B,A,
有环:A,E,H,F,E,
路径:A,E,H,F,I,
有环:A,E,H,G,D,A,
有环:A,E,H,G,D,E,
路径:A,E,H,I,
------ 寻找起点到终点的所有路径结束 ------


原创博文，转载请注明出处。

冰冻火山
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
无向图(java)
klz
12-19 2902
文章目录无向图术语邻接矩阵api设计代码实现邻接矩阵测试邻接表实现无向图api设计代码实现邻接表测试 无向图术语 定义：图是由一组顶点和一组能够将两个顶点相连的边组成的 表示方式 邻接矩阵： 使用二维数组实现，容易造成空间的浪费 邻接表： 使用数组和链表实现 图的述语 相邻顶点： 两个顶点通过一条边相连时，称这两个顶点是相邻顶点 度：某个顶点相邻顶点的个数叫做这个顶点的度 子图：边的子集和边所依赖的顶点组成的图叫做子图 路径：边和边所依赖的顶点组成路径 环：起点和终点相同 连通图：图中任意两个顶点存在
1059 从始点到终点的所有路径
weixin_44171872的博客
10-22 1259
题目描述： 给定有向图的边 edges，以及该图的始点 source 和目标终点 destination，确定从始点 source 出发的所有路径是否最终结束于目标终点 destination，即： 从始点 source 到目标终点 destination 存在至少一条路径 如果存在从始点 source 到没有出边的节点的路径，则该节点就是路径终点。 从始点source到目标终点 destination 可能路径数是有限数字 当从始点 source 出发的所有路径都可以到达目标终点 destination
无向图求起点到终点所有路径
qq_32310175的博客
09-18 2646
无向图求起点到终点所有路径 public class Node { public String name = null; public ArrayList<Node> relationNodes = new ArrayList<Node>(); public String getName() { return name; }...
无向无权图的最短路径数
7cqyz_Ycz的博客
07-10 2071
【问题描述】 　　给出 n 个顶点（编号为1..n），m 条边的无向无权图，请计算 1 到 n 的最短路径数目（只要有一条边不同，就是两条不同的路径）。【输入格式】 　　第一行包含两个整数：n,m，表示图的顶点和边的数目。 　　接下来的m行，每行包含2个整数：a,b（(1 ≤ a, b ≤ n），表示图的一条边关联的顶点为a,b。【输出格式】 　　一个整数，表示 1 到 n 的最短路径数目。
有向图中以一个顶点为起始点的所有路径
m0_38138446的博客
07-07 7959
有向图的路径发现，从一个顶点出发，找到以该顶点为起始点的所有路径
快递求最短路径
01-11
1. 迪杰斯特拉算法：适用于无权边或非负权重的有向图，从一个起点开始，逐步扩展最短路径，直到找到所有顶点的最短路径。它使用优先队列（通常用堆实现）来维护待处理的顶点，每次选取距离起点最近的未处理顶点进行...
计算机软件及应用数据结构图PPT学习教案.pptx
10-11
简单路径是不包含重复顶点的路径，而回路或环则是起点和终点相同的路径。路径长度在无权图中由边的数量决定，在带权图中则由边的权值总和计算。 通过理解和熟练运用这些概念，可以解决诸如寻找最短路径、网络优化等...
数据结构-图部分.pdf
09-30
有向图的边是有方向的，表示为尖括号，vj>，其中vi是边的起点（弧尾），vj是终点（弧头）。无向图的边则是无方向的，表示为圆括号(vi，vj)，代表两个顶点之间的连接不分先后。无向图的边数受到顶点数的限制，最多...
数据结构（图）的教程
05-10
连通图是指图中任意两个顶点间都有路径可达，强连通图则要求有向图中任意两点之间既有从A到B的路径，也有从B到A的路径。连通分量和强连通分量是图中最大的连通子图和强连通子图。 接着，我们讨论图的存储结构，常见...
数据结构（图的建立）——C语言
10-21
这些算法能帮助我们探索图的所有路径或者找到特定的路径。 总的来说，理解并能用C语言实现图的建立是掌握数据结构的关键步骤。这不仅需要对C语言的基本语法有深入理解，还需要熟悉图的各种操作和算法。通过不断的...
某种带权有向无环图(graph)的所有路径的求法
dengdi8115的博客
07-21 456
// 讨论QQ群：135202158 最近做某个东西，最后用图实现了，这里总结一下算法。 假设有以下带权有向无环图（连通或非连通，我这里用的是非连通的）： 每个节点(node)可能与其他节点有向地相连，相邻节点的边（edge)有权值(weight)属性。从一个节点到任意一个节点的连的集合称为路径(path)，且路径的权为各边权的最小值。 现在的问题就是求所有可能的路径，...
无向图两点间所有路径（python）
朱家小旺
05-25 8890
方法一，通过回溯查找 假如我们要查找的图为： 通过一个字典进行保存： graph = {"A":["B","C"], "B":["A","C","D"], "C":["A","B","D","E"], "D":["B","C","E","F"], "E":["C","D"], "F":["D"], ...
无向图深搜输出两点间所有路径
gigggg的博客
08-09 3470
void DFS(int now) { set[now]=1; stack[++top]=now; if(now==n) PrinPath(); for(int i=1;i<=n;++i) if(set[i]==0&&Map[now][i]<INF) DFS(i); top--; set[now]=0; } void PrintPath()...
python中判断无向图是否有环_图03---图的遍历
weixin_39837352的博客
11-22 621
图的遍历 (graph traversal) 给出一个图G和其中任意一个顶点V0， 从V0出发系统地访问G中所有的顶点， 每个顶点访问而且只访问一次 • 深度优先遍历 • 广度优先遍历 • 拓扑排序图遍历的考虑从一个顶点出发，试探性访问其余 顶点，同时必须考虑到下列情况 • 从一顶点出发，可能不能到达所有其 它的顶点 ,如 非连通图； • 也有可能会陷入死循环 , 如 存在回路的图解决办法为每个顶...
数据结构无向图简单路径
weixin_43930849的博客
07-06 5736
数据结构无向图简单路径 一．课程设计目的和要求 目的：锻炼学生对软件界面设计并进行实现的实践能力。 要求：（1）完成课程设计所给的所有功能。 （2）根据课程设计的特点设计出相应的画面。 二．课程设计环境 windows, DEVC++，Qt5.5 三．课程设计内容 （1）求出无向图中从起点到终点的所有简单路径。其中起点和终点可以由用户自行设定。 （2）求出无向图中从起点到终点的指定长度（如K）的所...
R7-12 求最少跳数
shuyuan12346的博客
05-22 227
本题目要求输入一个无向无权图，求起点到终点的最少跳数。
JAVA路线（1）
blaccck的博客
04-20 110
方法： 不返回值时，返回值类型可以使用void 使用void时，可以使用return提前结束方法调用 public static 返回值类型 方法名称（参数类型 变量...）{ //该方法要执行的代码 return 返回值； 方法的重载：名字一样，类型不同 方法重载的返回值类型应相同，只有参数可以不同 public static int sum(int x,int y) { return ...
求从A到B的路径条数（Java）
ln01010的博客
11-26 639
求从A到B的路径条数 （牛客网—牛客题霸算法篇—NC34） 题目描述 一个机器人在m×n大小的地图的左上角（起点）。 机器人每次可以向下或向右移动。机器人要到达地图的右下角（终点）。 可以有多少种不同的路径从起点走到终点？ 思路 Java实现 使用动态规划 到第一行和第一列每个格子的路径数都是1 到其他格子的路径数等于到它上一个格子和到它左侧格子的路径数之和。 代码实现 import java.util.*; public class Solution { /** * *
教你一招｜Python实现无向图最短路径
python学习者的博客
11-21 4334
一心想学习算法，很少去真正静下心来去研究，前几天趁着周末去了解了最短路径的资料，用python写了一个最短路径算法。算法是基于带权无向图去寻找两个点之间的最短路径，数据存储用邻接矩阵记录。首先画出一幅无向图如下，标出各个节点之间的权值。 更多Python视频、源码、资料加群683380553免费获取 其中对应索引： A ——&gt; 0 B ——&gt; 1 C ——&gt; ...
求解无向无权网络中的平均最短路径长度的公式
最新发布
05-31
在无向无权网络中，计算平均最短路径长度可以使用以下公式： $$L = \frac{1}{n(n-1)}\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}d_{ij}$$ 其中，$n$是图中节点的数量，$d_{ij}$是节点$i$和节点$j$之间的最短路径长度。在实现时，可以使用NetworkX库中的`average_shortest_path_length`函数来计算平均最短路径长度。以下是使用NetworkX库计算平均最短路径长度的代码示例： ```python import networkx as nx G = nx.Graph() # 创建一个无向图 # 添加节点和边 G.add_edges_from([(1,2),(2,3),(3,4),(4,5),(5,1),(2,5),(3,5),(4,1)]) avg_shortest_path_length = nx.average_shortest_path_length(G) print(f"平均最短路径长度为{avg_shortest_path_length}") ``` 输出结果为： ``` 平均最短路径长度为1.6 ``` 这意味着，该图中任意两个节点之间的平均最短路径长度为1.6。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值