精华内容
下载资源
问答
  • 在如果有向图中存在或不存在循环,以下代码将返回True或False:def cycle_exists(G):color = { u : "white" for u in G }found_cycle = [False]for u in G:if color[u] == "white":dfs_visit(G, u, color, found_...

    我希望能够找到有向图和无向图中的所有圈。在

    如果有向图中存在或不存在循环,以下代码将返回True或False:def cycle_exists(G):

    color = { u : "white" for u in G }

    found_cycle = [False]

    for u in G:

    if color[u] == "white":

    dfs_visit(G, u, color, found_cycle)

    if found_cycle[0]:

    break

    return found_cycle[0]

    def dfs_visit(G, u, color, found_cycle):

    if found_cycle[0]:

    return

    color[u] = "gray"

    for v in G[u]:

    if color[v] == "gray":

    found_cycle[0] = True

    return

    if color[v] == "white":

    dfs_visit(G, v, color, found_cycle)

    color[u] = "black"

    如果无向图中存在或不存在循环,以下代码将返回True或False:

    ^{pr2}$

    我如何使用这些来找出有向图和无向图中存在的所有循环?在

    展开全文
  • 有向图:主要有深度优先和拓扑排序2中方法1、拓扑排序,如果能够用拓扑排序完成对图中所有节点的排序的话,就说明这个图中没有,而如果不能完成,则说明有。2、可以用Strongly Connected Components来做,我们...

    有向图:

    主要有深度优先和拓扑排序2中方法

    1、拓扑排序,如果能够用拓扑排序完成对图中所有节点的排序的话,就说明这个图中没有环,而如果不能完成,则说明有环。

    2、可以用Strongly Connected Components来做,我们可以回忆一下强连通子图的概念,就是说对于一个图的某个子图,该子图中的任意u->v,必有v->u,则这是一个强连通子图。这个限定正好是环的概念。所以我想,通过寻找图的强连通子图的方法应该可以找出一个图中到底有没有环、有几个环。

    3、就是用一个改进的DFS

    刚看到这个问题的时候,我想单纯用DFS就可以解决问题了。但细想一下,是不能够的。如果题目给出的是一个无向图,那么OK,DFS是可以解决的。但无向图得不出正确结果的。比如:A->B,A->C->B,我们用DFS来处理这个图,我们会得出它有环,但其实没有。

    我们可以对DFS稍加变化,来解决这个问题。解决的方法如下:

    图中的一个节点,根据其C[N]的值,有三种状态:

    0,此节点没有被访问过

    -1,被访问过至少1次,其后代节点正在被访问中

    1,其后代节点都被访问过。

    按照这样的假设,当按照DFS进行搜索时,碰到一个节点时有三种可能:

    1、如果C[V]=0,这是一个新的节点,不做处理

    2、如果C[V]=-1,说明是在访问该节点的后代的过程中访问到该节点本身,则图中有环。

    3、如果C[V]=1,类似于2的推导,没有环。    在程序中加上一些特殊的处理,即可以找出图中有几个环,并记录每个环的路径

    无向图:

    方法1:

    如果存在回路,则必存在一个子图,是一个环路。环路中所有顶点的度>=2。

    n

    第一步:删除所有度<=1的顶点及相关的边,并将另外与这些边相关的其它顶点的度减一。

    第二步:将度数变为1的顶点排入队列,并从该队列中取出一个顶点重复步骤一。

    如果最后还有未删除顶点,则存在环,否则没有环。

    n算法分析:

    由于有m条边,n个顶点。

    i)如果m>=n,则根据图论知识可直接判断存在环路。(证明:如果没有环路,则该图必然是k棵树 k>=1。根据树的性质,边的数目m = n-k。k>=1,所以:m

    ii)如果m

    注:

    该方法,算法复杂度不止O(V),首先初始时刻统计所有顶点的度的时候,复杂度为(V + E),即使在后来的循环中E>=V,这样算法的复杂度也只能为O(V + E)。其次,在每次循环时,删除度为1的顶点,那么就必须将与这个顶点相连的点的度减一,并且执行delete node from list[list[node]],这里查找的复杂度为list[list[node]]的长度,只有这样才能保证当degree[i]=1时,list[i]里面只有一个点。这样最差的复杂度就为O(EV)了。

    方法2:

    DFS搜索图,图中的边只可能是树边或反向边,一旦发现反向边,则表明存在环。该算法的复杂度为O(V)。

    方法3:

    PS:此方法于2011-6-12补充

    假定:图顶点个数为M,边条数为E

    遍历一遍,判断图分为几部分(假定为P部分,即图有 P 个连通分量)

    对于每一个连通分量,如果无环则只能是树,即:边数=结点数-1

    只要有一个满足      边数   >   结点数-1

    原图就有环

    将P个连通分量的不等式相加,就得到:

    P1:E1=M1-1

    P2:E2=M2-1

    ...

    PN:EN>MN-1

    所有边数(E)   >   所有结点数(M) - 连通分量个数(P)

    即:  E + P > M  所以只要判断结果  E  + P > M 就表示原图有环,否则无环.

    实例代码如下:

    如果要将有向图中的环输出:

    boolDecoder::FindCycle(std::vector > &g, std::vector &c)

    {

    intsize = g.size();

    vector color(size,0);//所有的结点都没有被访问。当i结点为0,未被访问;i为-1,环;i为1,i的所有后裔结点都被访问过

    //for (int i=0;i

    for(inti= size -1;i>=0;--i)

    {

    if(color[i]==0)

    {

    color[i] = -1;

    if(Dfs(g,color,c,i))

    {

    //c.push_back(i);

    returntrue;

    }

    }

    }

    returnfalse;

    }

    boolDecoder::Dfs(std::vector > &g, std::vector &color, std::vector &c,inti)//如果有返回到i的环,则true;否则,false.遍历结点i的所有后继

    {

    intsize = g.size();

    for(intj=0;j

    {

    if(g[i][j] !=noEdge)

    {

    if(color[j]==0)

    {

    color[j] = -1;

    if(Dfs(g,color,c,j))

    {

    //c.push_back(j);

    returntrue;

    }

    }

    elseif(color[j] == -1)

    {

    c.push_back(j);

    intstart = j;

    for(intind = 0;ind 

    {

    if(g[start][ind] !=noEdge && color[ind] == -1)

    {

    if(ind == j)

    break;

    c.push_back(ind);

    start = ind;

    }

    }

    returntrue;

    }

    }

    }

    color[i] = 1;

    returnfalse;

    }

    用拓扑排序查找有向图的环有如下的缺点

    展开全文
  • 查找有向图中所有

    千次阅读 2018-06-30 12:30:00
    因为这些点若还构成其它的,那么在递归到该点时会查找出来。 本方法输出的,结点不是按其在环中的先后位置排列的。 1 import java.util.*; 2 3 public class GetAllCyclesForDire...

    在对每个结点进行DFS的基础上进行了一些优化。

    优化原理:在findCycle(v,e) 中访问过的点,不再进行findCycle().  因为这些点若还构成有其它的环,那么在递归到该点时会查找出来。

    本方法中输出的环,结点不是按其在环中的先后位置排列的。

     1 import java.util.*;
     2 
     3 public class GetAllCyclesForDirectedGraph{
     4 static List<Integer> trace;
     5 static Set<Integer> searched=new HashSet<>();
     6 static Set<List<Integer>> allCircles = new HashSet<>();
     7 
     8 public static void main(String[] args) {
     9  int n=7; 
    10 int[][] e={ {0,1,1,0,0,0,0}, {0,0,0,1,0,0,0}, 
    11             {0,0,0,0,0,1,0}, {0,0,0,0,1,0,0}, 
    12             {0,0,1,0,0,0,0}, {0,0,0,0,1,0,1}, 
    13             {1,0,1,0,0,0,0}};
    14 for(int i=0;i<n;i++){
    15 if(searched.contains(i)) 
    16 continue;
    17 trace =new ArrayList<>();
    18 findCycle(i,e); 
    20 }
    21 
    22 for(List<Integer> list:allCircles)
    23 System.out.println("circle: "+list);
    24 }
    25 
    26 
    27 static void findCycle(int v, int[][]e){
    28 int j=trace.indexOf(v); 
    29 if(j!=-1) {

    31 List<Integer> circle=new ArrayList<>(); 32 while(j<trace.size()) {

    35 circle.add(trace.get(j)); 36 j++; 37 } 39 Collections.sort(circle); allCircles.add(circle); 42 return; 43 } 44 45 46 trace.add(v); 47 for(int i=0;i<e.length;i++) { 48 if(e[v][i]==1){
    searched.add(i);
    49 findCycle(i,e); 50 } 51 } 52 trace.remove(trace.size()-1); 53 } 54 55 }
    
    

     

     

     

    转载于:https://www.cnblogs.com/black-fish/p/9246701.html

    展开全文
  • 最近想写一个识别线程死锁的算法,在网上找了半天没有合适的代码,自己写了个查找有向图中的代码(可以将死锁的资源依赖建模成含的有向图)。本代码经过充分测试,内部有详细说明,可以放心下载。
  • 利用深度遍历有向图。 [img=https://img-bbs.csdn.net/upload/201603/15/1458048600_748462.jpg][/img][img=https://img-bbs.csdn.net/upload/201603/15/1458048327_359946.jpg][/img][img=...
  • 招银网络科技编程题,找到以某个节点为初始节点的所有环 package Java; import java.util.*; public class Test { static List<Integer> trace;// 搜索路径上的路径 static Set<Integer> searched =...

    图这一块掌握的不是很熟练。
    招银网络科技编程题,找到以某个节点为初始节点的所有环

    package Java;
    
    import java.util.*;
    
    public class Test {
    	static List<Integer> trace;// 搜索路径上的路径
    	static Set<Integer> searched = new HashSet<>();// 是否访问,可以用数组0/1
    	static Set<List<Integer>> allCircles = new HashSet<>();// 所有结果
    
    	public static void main(final String[] args) {
    		final int n = 7;
    		final int[][] e = { { 0, 1, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 1, 0 },
    				{ 0, 0, 0, 0, 1, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0 }, { 0, 0, 0, 0, 1, 0, 1 }, { 1, 0, 1, 0, 0, 0, 0 } };
    
    		// 以每个点开头都需要遍历一下
    		for (int i = 0; i < n; i++) {
    			// 如果还未访问到当前节点,说明它前面的节点已经遍历完成了,就可以新开启一条路径
    			if (searched.contains(i))
    				continue;
    			trace = new ArrayList<>();
    			findCycle(i, e);
    		}
    
    		for (List<Integer> list : allCircles)
    			System.out.println("circle: " + list);
    	}
    
    	// 当前遍历到v,
    	static void findCycle(int v, int[][] e) {
    		// 找到当前节点在目前遍历路径上的下标(是否存在)
    		int j = trace.indexOf(v);
    		// 如果存在,说明成环
    		if (j != -1) {
    			List<Integer> circle = new ArrayList<>();
    			// 保存路径上成环的这一圈
    			while (j < trace.size()) {
    				circle.add(trace.get(j));
    				j++;
    			}
    			// Collections.sort(circle);
    			allCircles.add(circle);
    			return;
    		}
    		// 如果不存在添加到路径,继续遍历
    		trace.add(v);
    		for (int i = 0; i < e.length; i++) {
    			// 遍历所有可达邻居
    			if (e[v][i] == 1) {
    				// 标记此邻居已访问
    				searched.add(i);
    				findCycle(i, e);
    			}
    		}
    		// 回溯,删除此节点,即以它的兄弟节点为开头继续遍历
    		trace.remove(trace.size() - 1);
    	}
    
    }
    
    展开全文
  • 该算法是实现打印出有向图中所有环,图采用邻接表表示,然后用一个栈来遍历,用一个向量来查找是否有环……有点不足的是有些情况会出现重复的环……我把一个工程直接放在里面,顶点输入时按数字编号,如顶点0,1,...
  • 有向图中所有环--深度遍历暴力求解

    万次阅读 多人点赞 2020-04-02 14:00:33
    每个点都进行深度遍历,找到以这个点为起点的。。。数据再大一点应该就不行了。。。 代码写得烂,仅供参考。。 #include "bits/stdc++.h" using namespace std; void dfs(const vector<vector<int&...
  • 查找有向图中

    千次阅读 2016-07-18 08:50:34
    有向图:主要有深度优先和拓扑排序2中方法1、拓扑排序,如果能够用拓扑排序完成对图中所有节点的排序的话,就说明这个图中没有,而如果不能完成,则说明有。2、可以用Strongly Connected Components来做,我们...
  • from copy import deepcopy as dc # 用集合去除重复路径 ans = set() def dfs(graph,trace,start): trace = dc(trace) # 深拷贝,对... # 如果下一个点在trace,则返回 if start in trace: index = trace....
  • NULL 博文链接:https://128kj.iteye.com/blog/1717469
  • 借鉴:... 由图中可以看出,"4"号点已经没有子节点,所以DFS以该点为起点的话,没有办法遍历整个图,所以没有办法找出。 这也是为什么程序的运行结果与起始点有关。
  • 本文简要介绍Johnson的在有向图中寻找简单化的算法。
  • DFS 查找有向图中

    千次阅读 2018-03-28 10:34:10
    分析:首先那个样例来说 0 1 1 00 0 1 01 0 0 10 0 0 1四个定点(0,1,2,3),1代表xi到xj路.第一步:构造矩阵,也就是二维数组。第二步:选择起点进行深度探索,以0为起点第三步:开始探索: 0进栈或者用数组...
  • 说明:我们选择的图是有向图,图的存储方式是邻接矩阵,使用C++语言,基于vs2010平台 算法思想:逐个对图的出度不为0的点进行遍历。假如是先对图A节点进行遍历:首先,将A节点所连接的点存储在数组vect1,然后...
  • 判断有向图是否有

    千次阅读 2018-08-28 00:25:48
    要想对一副有向图进行拓扑排序,必须要保证有向图是无的,那么我们如何判断图是否含有呢?我们可以使用深度优先搜索来遍历图,并创建一个数组来标记顶点是否已经在递归栈,这样,当一个顶点指向的顶点已经在...
  • 有向图查找

    2020-10-15 16:54:02
    有向图查找 import java.util.Scanner; import java.util.Stack; //功能:有向图寻找,并且找出这个; //找出的这个是第一个能出现的,并且之此一个,其他的在有不进行查找 public class DirectedCycle...
  • 原标题:拓扑排序-有向环图中的最长路径给定一个加权d irected (DAG)和一个源点s在它,找到从s中最长的距离在给定图中所有其他顶点。一般图的最长路径问题并不像最短路径问题那么容易,因为最长路径问题没有最优...
  • 求一无向图G中所有环

    2008-03-13 09:05:00
    1. 判断N结点的无向图G是否有环 假定:结点个数为M,边条数为E 遍历一遍,判断图分为几部分(假定为P部分,即图 P 个连通分量) 对于每一个连通分量,如果无则只能是树,即:边数=结点数-1 只要一个...
  • 有向图中两点间所有路径
  • 有向图、无向图是否有的判断

    千次阅读 2016-07-21 20:54:32
    今天在做数据库的调度冲突可串行...判断无向图中是否存在回路()的算法描述 如果存在回路,则必存在一个子图,是一个环路。环路中所有顶点的度>=2。 算法:  第一步:删除所有度  第二步:将度数
  • 百度百科:对一个有向图(Directed Acyclic Graph简称DAG)G进行拓扑排序,是将G中所有顶点排成一个线性序列,使得图中任意一对顶点u和v,若边<u,v>∈E(G),则u在线性序列中出现在v之前。通常,这样的线性...
  • https://blog.csdn.net/qq_35644234/article/details/60578189拓扑排序的实现步骤在有向图中选一个没有前驱的顶点并且输出从图中删除该顶点和与它有关的边重复上述两步,直至所有顶点输出...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,824
精华内容 1,129
关键字:

有向图中所有环