Check if a digraph is a DAG (Directed Acyclic Graph 有向无环图) or not

已于 2022-05-28 14:37:16 修改
阅读量408 收藏
点赞数
分类专栏： 【语言与编译】 文章标签： 图论
于 2022-05-28 14:36:06 首次发布
原文链接：https://www.techiedelight.com/check-given-digraph-dag-directed-acyclic-graph-not/
版权

Check if a digraph is a DAG (Directed Acyclic Graph) or not

Detect Cycle in a Directed Graph - GeeksforGeeks

 

Check if a digraph is a DAG (Directed Acyclic Graph) or not

Given a directed graph, check if it is a DAG (Directed Acyclic Graph) or not. A DAG is a digraph (directed graph) that contains no cycles.

The following graph contains a cycle 0—1—3—0, so it’s not DAG. If we remove edge 3–0 from it, it will become a DAG.

Recommended Read:

Types of edges involved in DFS and relation between them

Arrival and departure time of vertices in DFS

 
We can use Depth–first search (DFS) to solve this problem. The idea is to find if any back-edge is present in the graph or not. A digraph is a DAG if there is no back-edge present in the graph. Recall that a back-edge is an edge from a vertex to one of its ancestors in the DFS tree.

 
Fact: For an edge u —> v in a directed graph, an edge is a back edge if departure[u] < departure[v].

Proof: We have already discussed the relationship between all four types of edges involved in the DFS in the previous post. Following are the relationships we have seen between the departure time for different types of edges involved in a DFS of a directed graph:

Tree edge (u, v): departure[u] > departure[v]
Back edge (u, v): departure[u] < departure[v]
Forward edge (u, v): departure[u] > departure[v]
Cross edge (u, v): departure[u] > departure[v]

Note that for tree edge, forward edge and cross edge, departure[u] > departure[v]. But only for the back edge, the relationship departure[u] < departure[v] holds true. So, it is guaranteed that an edge (u, v) is a back-edge, not some other edge if departure[u] < departure[v].

#include <iostream>
#include <vector>
using namespace std;
 
// Data structure to store a graph edge
struct Edge {
    int src, dest;
};
 
// A class to represent a graph object
class Graph
{
public:
    // a vector of vectors to represent an adjacency list
    vector<vector<int>> adjList;
 
    // Graph Constructor
    Graph(vector<Edge> const &edges, int n)
    {
        // resize the vector to hold `n` elements of type `vector<int>`
        adjList.resize(n);
 
        // add edges to the directed graph
        for (auto &edge: edges) {
            adjList[edge.src].push_back(edge.dest);
        }
    }
};
 
// Perform DFS on the graph and set the departure time of all vertices of the graph
int DFS(Graph const &graph, int v, vector<bool>
    &discovered, vector<int> &departure, int &time)
{
    // mark the current node as discovered
    discovered[v] = true;
 
    // do for every edge (v, u)
    for (int u: graph.adjList[v])
    {
        // if `u` is not yet discovered
        if (!discovered[u]) {
            DFS(graph, u, discovered, departure, time);
        }
    }
 
    // ready to backtrack
    // set departure time of vertex `v`
    departure[v] = time++;
}
 
// Returns true if given directed graph is DAG
bool isDAG(Graph const &graph, int n)
{
    // keep track of whether a vertex is discovered or not
    vector<bool> discovered(n);
 
    // keep track of the departure time of a vertex in DFS
    vector<int> departure(n);
 
    int time = 0;
 
    // Perform DFS traversal from all undiscovered vertices
    // to visit all connected components of a graph
    for (int i = 0; i < n; i++)
    {
        if (!discovered[i]) {
            DFS(graph, i, discovered, departure, time);
        }
    }
 
    // check if the given directed graph is DAG or not
    for (int u = 0; u < n; u++)
    {
        // check if (u, v) forms a back-edge.
        for (int v: graph.adjList[u])
        {
            // If the departure time of vertex `v` is greater than equal
            // to the departure time of `u`, they form a back edge.
 
            // Note that departure[u] will be equal to
            // departure[v] only if `u = v`, i.e., vertex
            // contain an edge to itself
            if (departure[u] <= departure[v]) {
                return false;
            }
        }
    }
 
    // no back edges
    return true;
}
 
int main()
{
    // vector of graph edges as per the above diagram
    vector<Edge> edges = {
        {0, 1}, {0, 3}, {1, 2}, {1, 3}, {3, 2}, {3, 4}, {3, 0}, {5, 6}, {6, 3}
    };
 
    // total number of nodes in the graph (labelled from 0 to 6)
    int n = 7;
 
    // build a graph from the given edges
    Graph graph(edges, n);
 
    // check if the given directed graph is DAG or not
    if (isDAG(graph, n)) {
        cout << "The graph is a DAG";
    }
    else {
        cout << "The graph is not a DAG";
    }
 
    return 0;
}

Output:

The graph is not a DAG

Java

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
// A class to store a graph edge
class Edge
{
    int source, dest;
 
    public Edge(int source, int dest)
    {
        this.source = source;
        this.dest = dest;
    }
}
 
// A class to represent a graph object
class Graph
{
    // A list of lists to represent an adjacency list
    List<List<Integer>> adjList = null;
 
    // Constructor
    Graph(List<Edge> edges, int n)
    {
        adjList = new ArrayList<>();
 
        for (int i = 0; i < n; i++) {
            adjList.add(new ArrayList<>());
        }
 
        // add edges to the directed graph
        for (Edge edge: edges) {
            adjList.get(edge.source).add(edge.dest);
        }
    }
}
 
class Main
{
    // Perform DFS on the graph and set the departure time of all
    // vertices of the graph
    private static int DFS(Graph graph, int v, boolean[] discovered,
                           int[] departure, int time)
    {
        // mark the current node as discovered
        discovered[v] = true;
 
        // do for every edge (v, u)
        for (int u: graph.adjList.get(v))
        {
            // if `u` is not yet discovered
            if (!discovered[u]) {
                time = DFS(graph, u, discovered, departure, time);
            }
        }
 
        // ready to backtrack
        // set departure time of vertex `v`
        departure[v] = time++;
 
        return time;
    }
 
    // Returns true if given directed graph is DAG
    public static boolean isDAG(Graph graph, int n)
    {
        // keep track of whether a vertex is discovered or not
        boolean[] discovered = new boolean[n];
 
        // keep track of the departure time of a vertex in DFS
        int[] departure = new int[n];
 
        int time = 0;
 
        // Perform DFS traversal from all undiscovered vertices
        // to visit all connected components of a graph
        for (int i = 0; i < n; i++)
        {
            if (!discovered[i]) {
                time = DFS(graph, i, discovered, departure, time);
            }
        }
 
        // check if the given directed graph is DAG or not
        for (int u = 0; u < n; u++)
        {
            // check if (u, v) forms a back-edge.
            for (int v: graph.adjList.get(u))
            {
                // If the departure time of vertex `v` is greater than equal
                // to the departure time of `u`, they form a back edge.
 
                // Note that departure[u] will be equal to
                // departure[v] only if `u = v`, i.e., vertex
                // contain an edge to itself
                if (departure[u] <= departure[v]) {
                    return false;
                }
            }
        }
 
        // no back edges
        return true;
    }
 
    public static void main(String[] args)
    {
        // List of graph edges as per the above diagram
        List<Edge> edges = Arrays.asList(
                new Edge(0, 1), new Edge(0, 3), new Edge(1, 2),
                new Edge(1, 3), new Edge(3, 2), new Edge(3, 4),
                new Edge(3, 0), new Edge(5, 6), new Edge(6, 3)
        );
 
        // total number of nodes in the graph (labelled from 0 to 6)
        int n = 7;
 
        // build a graph from the given edges
        Graph graph = new Graph(edges, n);
 
        // check if the given directed graph is DAG or not
        if (isDAG(graph, n)) {
            System.out.println("The graph is a DAG");
        }
        else {
            System.out.println("The graph is not a DAG");
        }
    }
}

Download  Run Code

Output:

The graph is not a DAG

Python

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
# A class to represent a graph object
class Graph:
    # Constructor
    def __init__(self, edges, n):
 
        # A list of lists to represent an adjacency list
        self.adjList = [[] for _ in range(n)]
 
        # add edges to the directed graph
        for (src, dest) in edges:
            self.adjList[src].append(dest)
 
 
# Perform DFS on the graph and set the departure time of all vertices of the graph
def DFS(graph, v, discovered, departure, time):
 
    # mark the current node as discovered
    discovered[v] = True
 
    # do for every edge (v, u)
    for u in graph.adjList[v]:
        # if `u` is not yet discovered
        if not discovered[u]:
            time = DFS(graph, u, discovered, departure, time)
 
    # ready to backtrack
    # set departure time of vertex `v`
    departure[v] = time
    time = time + 1
 
    return time
 
 
# Returns true if the given directed graph is DAG
def isDAG(graph, n):
 
    # keep track of whether a vertex is discovered or not
    discovered = [False] * n
 
    # keep track of the departure time of a vertex in DFS
    departure = [None] * n
 
    time = 0
 
    # Perform DFS traversal from all undiscovered vertices
    # to visit all connected components of a graph
    for i in range(n):
        if not discovered[i]:
            time = DFS(graph, i, discovered, departure, time)
 
    # check if the given directed graph is DAG or not
    for u in range(n):
 
        # check if (u, v) forms a back-edge.
        for v in graph.adjList[u]:
 
            # If the departure time of vertex `v` is greater than equal
            # to the departure time of `u`, they form a back edge.
 
            # Note that `departure[u]` will be equal to `departure[v]`
            # only if `u = v`, i.e., vertex contain an edge to itself
            if departure[u] <= departure[v]:
                return False
 
    # no back edges
    return True
 
 
if __name__ == '__main__':
 
    # List of graph edges as per the above diagram
    edges = [(0, 1), (0, 3), (1, 2), (1, 3), (3, 2), (3, 4), (3, 0), (5, 6), (6, 3)]
 
    # total number of nodes in the graph (labelled from 0 to 6)
    n = 7
 
    # build a graph from the given edges
    graph = Graph(edges, n)
 
    # check if the given directed graph is DAG or not
    if isDAG(graph, n):
        print('The graph is a DAG')
    else:
        print('The graph is not a DAG')
 

Download  Run Code

Output:

The graph is not a DAG

The time complexity of the above solutions is O(V + E), where V and E are the total number of vertices and edges in the graph, respectively.

Rate this post

rtoax
关注
专栏目录
随机生成有向无环图 DAG源代码示例（C语言）
01-02
有向无环图（Directed Acyclic Graph，DAG）是一种常见的数据结构，用于表示有向边和节点之间的关系。在计算机科学和信息技术领域，DAG 广泛应用于数据分析、机器学习、计算机网络等领域。以下是随机生成有向无环图 ...
AttributeError: 'NoneType' object has no attribute 'text'
热门推荐
royal_琦
10-12 1万+
今天训练遇到了问题，错误代码如下： AttributeError: 'NoneType' object has no attribute 'text' 问题是因为xml文件部分&lt;object&gt;下缺少&lt;name&gt;，从而产生的错误，补充即可。 ...
Python implementation of directed acyclic graph（python实现的有向无环图）
Lockey23的博客
07-27 1313
Python implementation of directed acyclic graph（python实现的有向无环图） 关于此实现可以在GitHub上找到开源模块 缘由：项目中用到了dag来表示某个数据分析的结果，然后需要转换成Excel来显示（此话题将在下一篇博客中） 然后又要将Excel内容以原样展示到网页中（此话题将在下下一篇博客中） python实现此数据结构的时候...
【Python】对一个有向无环图(Directed Acyclic Graph，DAG)G进行拓扑排序
RealEmperor 博客
06-05 1万+
拓扑排序 示例： 对一个有向无环图(Directed Acycqc Graph，DAG)G进行拓扑排序，是将G中所有顶点排成线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前 一种可能的拓扑排序结果2-&amp;amp;amp;amp;amp;gt;8-&amp;amp;amp;amp;amp;gt;0-&amp;amp;amp;amp;amp;gt;3-&amp;amp;amp;amp;amp;gt;7-&am
有向无环图Directed Acyclic Graph（DAG）
忄凝^的博客
08-01 7899
1、DAG 有向无环图Directed Acyclic Graph（DAG） DAG是一个没有 有向循环的、有限的有向图 。 它由有限个顶点和有向边组成，每条有向边都从一个顶点指向另一个顶点； 从任意一个顶点出发都不能通过这些有向边回到原来的顶点。 有向无环图就是从一个图中的任何一点出发，不管走过多少个分叉路口，都没有回到原来这个 点的可能性。 条件 每个顶点出现且只出现一次 若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。 计算一个DAG的拓扑关系
拓扑排序-有向无环图（DAG, Directed Acyclic Graph）
dengpan1889的博客
02-18 2831
条件： 1.每个顶点出现且只出现一次。 2.若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。 有向无环图（DAG）才有拓扑排序，非DAG图没有拓扑排序一说。 一般用有向边指示顺序关系，运用于顺序关系。 例如，下面这个图： 显然是一个DAG图，1→4表示4的入度+1，4是1的邻接点, 代码表示：前者deg[4]++;后者用vecto...
用 Python 代码判断有向图和无向图的连通性
08-10
### 有向图与无向图连通性判断详解 #### 一、有向图与无向图的基础概念 **1.1 有向图（Directed Graph）** - **定义**：有向图由一组节点（vertices）和一组带有方向的边（edges）组成。每条边从一个节点指向另一...
simplify-dag:给定一个有向无环图，收缩直线运行到单个顶点
06-08
简化-dag 给定一个有向无环图，将直线简化为单个顶点。 const simplify = require ( 'simplify-dag' )const digraph = require ( 'digraph-tag' )let graph = digraph ` A -> B B -> C C -> D X -> Y Y -> Z Z -> D ...
directed-graph-to-dag:给定一个有向图，返回一组要反转的边以消除任何循环
06-14
有向图到 dag 给定一个有向图，返回一些可能需要从图中删除所有循环的边。 const toDAG = require('directed-graph-to-dag') const digraph = require('digraph-tag') const graph = digraph` A -> B B -> C C...
Python笔记——nextworkx有向图
12-22
环境：ubuntu16.04，python2.7.12 版本：networkx==2.2, matplotlib==1.5.1, numpy==1.11.0 ...创建图 ...graph = nx.DiGraph() 节点 添加节点： graph.add_node(1) graph.add_node(2, value=float('inf'
操作系统复习四
qq_51884931的博客
12-14 262
ch4 Deadlock Deadlock: A set of blocked processes each holding a resource and waiting to acquire a resource held by another process in the set. –The system model for deadlocks first requires a process request a resource, then use the resource, and finally
Guava中Graph的操作说明（Guava 23）
kanpiaoxue的专栏
08-11 3918
来源： https://github.com/google/guava/wiki/GraphsExplained Graphs, Explained Guava's common.graph is a library for modeling graph-structured data, that is, entities and the relationships between the...
Graph简述
只会啃书的博客
11-16 1224
Graph remarks: 从bear导入的，不可见图为草稿，重点部分都有写。 基础 1. 术语 连通图(connected graph)：如果从任意一个顶点都存在一条路径到达另一个任意顶点（undirected graph） 树：是一幅无环无向连通图 森林：1个or几个树 简单路径(simple path)：一条没有重复顶点的路径 简单环(simple cycle)：一条（除了起点和终点必须相同之外）不含有重复顶点和边的环 adjacent: when 2 v are connected by a si
算法导论 影印版 勘误
wayne 我的陋室我做主
09-27 4058
引自:http://www.cs.dartmouth.edu/~thc/clrs-2e-bugs/bugs.phpSeverity levels A minor typographical error that should not affect your understanding (46 errors in first printing). A minor technical or expos
[基本算法] Detect Cycle in Directed/Undirected Graph 有向图/无向图找环
weixin_33973609的博客
06-11 372
Detect Cycle in Directed Graph 有向图找环 Given n nodes labeled from 0 to n - 1 and a list of directed edges (each edge is a pair of nodes), write a function to check whether...
Detect cycle in an undirected graph
Nonomeme的专栏
10-20 1039
Given an undirected graph, how to check if there is a cycle in the graph? For example, the following graph has a cycle 1-0-2-1. We have discussed cycle detection for directed graph. We have also di
Detect cycle in a directed graph
weixin_30430169的博客
09-09 224
Question:Detect cycle in a directed graph Answer: Depth First Traversal can be used to detect cycle in a Graph. DFS for a connected graph produces a tree. There is a cycle in a graph only if t...
图论导引 - 目录、引言、第一章 - 11/05
最新发布
chan_lay的博客
11-05 832
学习图论的前提：具备基本的初等集合论、矩阵论知识，了解抽象代数知识。本书可以分为四部分：第 1 ~ 4 章节：基础部分，包括图的定义和示例、连通性、欧拉路径和哈密顿路径等。第 5 ~ 6 章：关于平面性和着色的内容，特别提及了四色定理。第 7 ~ 8 章：有向图理论和横截理论，应用于关键路径分析、马尔可夫链、网络流第 9 章：拟阵，联系前面章节，并介绍最新的发展图、点、边、度顶点 vertices边 edge图 graph一个图是一组顶点以及顶点如何连接的表示。任何度量属性都是无关紧要的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值