Esempio n. 1
0
def createRandomDagIter(n: int) -> DirectedGraph:
    newGraph = DirectedGraph()

    # creates n nodes for the graph
    for i in range(0, n):
        newGraph.addNode(i)

    nodes = newGraph.getAllNodes()
    for i in range(0, random.randint(1, n * n)):
        first = nodes[random.randint(0, n - 1)]
        second = nodes[random.randint(0, n - 1)]

        if (first == second):
            continue

        if second in newGraph.adjList[first] or first in newGraph.adjList[
                second]:
            continue

        if (len(newGraph.adjList[first]) == 2):
            continue

        newGraph.addDirectedEdge(first, second)
        if newGraph.isAcyclic(first) is False:
            newGraph.removeDirectedEdge(first, second)
    return newGraph
 def __init__(self):
     self.getUserInput()
     self.initOperations()
     verticesList = self.getVerticesList()
     self.graph = DirectedGraph(verticesList)
     self.addEdgesToGraph()
     self.graph.topologicalSort()
Esempio n. 3
0
    def __init__(self, file_name, seperator):
        # First pass reading the file
        self._hash_table = LPHashTable(
        )  # This hash table is used to convert from key to vertex index
        self._graph = None  # The actual underlying directed graph

        file = open(file_name, "r")
        count = 0
        lines = file.read().splitlines()
        for line in lines:
            data = line.split(seperator)
            # Continuously adding keys to the hash table along with the corresponding index
            for key in data:
                if not self._hash_table.contains(key):
                    self._hash_table.put(key, count)
                    count += 1

        self._keys = np.empty(
            count, dtype=object)  # This array to convert index to key
        for name in self._hash_table.keys():
            self._keys[self._hash_table.get(name)] = name

        file.close()

        # Second pass, Build the actual graph after knowing exactly how many vertices we will need
        second_pass = open(file_name)
        self._graph = DirectedGraph(count)
        lines = second_pass.read().splitlines()
        for line in lines:
            data = line.split(seperator)
            start = self._hash_table.get(data[0])
            for i in range(1, len(data)):
                self._graph.add_edge(start, self._hash_table.get(data[i]))

        second_pass.close()
Esempio n. 4
0
    def initializeInDegreeMap(graph: DirectedGraph) -> dict:
        inDegree = {}
        for node in graph.getAllNodes():
            inDegree[node] = 0

        for node in graph.getAllNodes():
            for neighbor in node.neighbors:
                inDegree[neighbor] += 1

        return inDegree
 def setUp(self):
     self.v = Vertex('v')
     self.w = Vertex('w')
     self.x = Vertex('x')
     self.e1 = Arc(self.v, self.w)
     self.e2 = Arc(self.w, self.x)
     self.e3 = Arc(self.x, self.v)
     
     self.dg = DirectedGraph([self.v, self.w, self.x], 
         [self.e1, self.e2, self.e3])
def tester():
    f = open('MST_tests.in', 'r')
    t = int(f.readline())
    for _ in range(t):
        size = int(f.readline())
        adj = [None] * size

        for i in range(size):
            adj[i] = [int(x) for x in f.readline().split()]
        soln = int(f.readline())
        print(kruskal(DirectedGraph(adj)) == soln)
def tester():
    f = open('SSP_tests.in', 'r')
    t = int(f.readline())
    for _ in range(t):
        size = int(f.readline())
        adj = [None] * size

        for i in range(size):
            adj[i] = [int(x) for x in f.readline().split()]
        soln = [int(x) for x in f.readline().split()]
        print(dijkstra(DirectedGraph(adj), 0) == soln)
Esempio n. 8
0
    def mDFS(graph: DirectedGraph) -> list():
        stack = []
        visited = [] 

        for node in graph.getAllNodes():
            if node not in visited:
                TopSort.DFSHelper(node, stack, visited, graph)

        output = [] 
        while (len(stack) > 0):
            output.append(stack.pop())
        return output 
    def test_ngon_with_chord(self):
        v1 = Vertex('v1')
        v2 = Vertex('v2')
        v3 = Vertex('v3')
        v4 = Vertex('v4')
        v5 = Vertex('v5')
        e1 = Arc(v2,v1)
        e2 = Arc(v3,v2)
        e3 = Arc(v3,v4)
        e4 = Arc(v4,v5)
        e5 = Arc(v5,v1)
        
        ngon = DirectedGraph([v1,v2,v3,v4,v5],
            [e1,e2,e3,e4,e5])
        
        self.assertFalse(ngon.has_knot())
        
        chord = Arc(v1,v4)
        ngon.add_edge(chord)

        self.assertTrue(ngon.has_knot())
Esempio n. 10
0
def createRandomDAGIter(n):
    randGraph = DirectedGraph()
    i = 0
    # Create n nodes
    while i < n:
        randGraph.addNode(i)
        i += 1

    # Assign each node 2 random nodesList (might assign 0, 1 or 2 nodesList)
    for i in range(len(randGraph.nodesList)):
        randList = []
        #retreive the length of nodesList
        size = len(randGraph.nodesList) - 1

        name = randGraph.nodesList[i].name
        #generate random number
        n1 = random.randint(name, size)  #d2
        n2 = random.randint(name, size)  #d1
        #if n1 generated is unique
        checkandCreate(randGraph, name, n1, n2, randList)

    return randGraph
class SQLConflictSerializable:
    graph = None
    userInput = None
    operations = []

    def __init__(self):
        self.getUserInput()
        self.initOperations()
        verticesList = self.getVerticesList()
        self.graph = DirectedGraph(verticesList)
        self.addEdgesToGraph()
        self.graph.topologicalSort()
        # self.graph.print()

    def initOperations(self):
        splittedInput = self.userInput.split(";")
        for command in splittedInput:
            indexOfP = command.find("(")
            operand = command[0]
            transactionsNumber = int(command[1:indexOfP])
            variable = command[indexOfP + 1:-1]
            operationToAdd = operation(operand, transactionsNumber, variable)
            self.operations.append(operationToAdd)

    def getVerticesList(self):
        listOfTransactions = []
        for operation in self.operations:
            if operation.transactionId not in listOfTransactions:
                listOfTransactions.append(operation.transactionId)
        return listOfTransactions

    def getUserInput(self):
        print("Please type your transactions list")
        self.userInput = input()

    def addEdgesToGraph(self):
        numberOfOperand = len(self.operations)
        for i in range(numberOfOperand):
            currentOperand = self.operations[i]
            for j in range(i + 1, numberOfOperand):
                if self.operations[j].variable == currentOperand.variable and self.operations[j].transactionId != currentOperand.transactionId:
                    if currentOperand.operand == 'R' and self.operations[j].operand == 'W':
                        self.graph.addEdge(currentOperand.transactionId, self.operations[j].transactionId)
                    elif currentOperand.operand == 'W' and self.operations[j].operand == 'R':
                        self.graph.addEdge(currentOperand.transactionId, self.operations[j].transactionId)
                    elif currentOperand.operand == 'W' and self.operations[j].operand == 'W':
                        self.graph.addEdge(currentOperand.transactionId, self.operations[j].transactionId)
Esempio n. 12
0
def createRandomDAGIter(n):
    """Creates n random nodes with randomly assigned, unweighted, directed edges."""
    graph = DirectedGraph()

    for i in range(n):
        graph.addNode(i)
        if i < 2:
            continue
        edge = random.sample(graph.getAllNodes(), 2)
        while not graph.addDirectedEdge(min(edge), max(edge)):
            edge = random.sample(graph.getAllNodes(), 2)

    return graph
Esempio n. 13
0
def createRandomDAGIter(n):
    # Create new DirectedGraph and add n amount of nodes to it
    g = DirectedGraph()
    for i in range(1, n + 1):
        g.addNode(createLabel(i))

    # Copy the list of the nodes from the graph
    # so we can pop from list
    nodes = g.getAllNodes().copy()

    # Shuffle the nodes so the graph doesn't
    # start with "A" every time
    shuffle(nodes)
    # While there are nodes in the list
    while len(nodes) > 0:
        cur = nodes.pop(0)
        if len(nodes) <= 1:
            break

        # XXX Choose a random amount of children XXX
        # Make nodes have 2 children
        num = 2  # randrange(1,len(nodes))

        # Add a random sample of num length
        # the neighbor of the cur
        for i in sample(nodes, num):
            g.addDirectedEdge(cur, i)

        # For every neighbor of cur do the same
        for n in cur.neighbors:
            nodes.pop(nodes.index(n))
            if len(nodes) <= 1:
                break
            num = 2  # randrange(1,len(nodes))
            for i in sample(nodes, num):
                g.addDirectedEdge(n, i)
    return g
Esempio n. 14
0
    def mDFS(graph: DirectedGraph) -> list:
        topSort = []
        visited = set()

        for node in graph.getAllNodes():
            stack = [node]
            while len(stack) != 0:
                curr = stack.pop()

                if curr not in visited:
                    visited.add(curr)

                n = len(stack)
                for neighbor in node.neighbors:
                    if neighbor not in visited:
                        stack.insert(n, neighbor)

            topSort.append(node)

        return topSort[::-1]
Esempio n. 15
0
    def Kahns(graph: DirectedGraph):
        output = []
        queue = []

        for node in graph.getAllNodes():
            if node.inDegree is 0:
                queue.append(node)

        while len(queue) is not 0:
            currNode = queue.pop(0)
            output.append(currNode)

            for neighbor in graph.adjList[currNode]:
                neighbor.inDegree = neighbor.inDegree - 1

                if neighbor.inDegree is 0:
                    queue.append(neighbor)

            currNode.inDegree = -1

        return output
class TestKnots(unittest.TestCase):
    def setUp(self):
        self.v = Vertex('v')
        self.w = Vertex('w')
        self.x = Vertex('x')
        self.e1 = Arc(self.v, self.w)
        self.e2 = Arc(self.w, self.x)
        self.e3 = Arc(self.x, self.v)
        
        self.dg = DirectedGraph([self.v, self.w, self.x], 
            [self.e1, self.e2, self.e3])
        
    def test_positive(self):
        
        #triangular knot
        self.assertEqual(self.dg.has_knot(), True)
  
        #triangular knot w/ an edge into it
        self.a = Vertex('a')
        self.dg.add_vertex(self.a)
        self.Kanye = Arc(self.a,self.v)
        self.dg.add_edge(self.Kanye)
        self.assertTrue(self.dg.has_knot())
    
    def test_ngon_with_chord(self):
        v1 = Vertex('v1')
        v2 = Vertex('v2')
        v3 = Vertex('v3')
        v4 = Vertex('v4')
        v5 = Vertex('v5')
        e1 = Arc(v2,v1)
        e2 = Arc(v3,v2)
        e3 = Arc(v3,v4)
        e4 = Arc(v4,v5)
        e5 = Arc(v5,v1)
        
        ngon = DirectedGraph([v1,v2,v3,v4,v5],
            [e1,e2,e3,e4,e5])
        
        self.assertFalse(ngon.has_knot())
        
        chord = Arc(v1,v4)
        ngon.add_edge(chord)

        self.assertTrue(ngon.has_knot())
Esempio n. 17
0
    return topological_list


def dfs_visit(graph: Graph, u: Any, time: int, status: dict,
              topological_list: LinkedList) -> None:
    """
    Completely explores each vertex connected to the source vertex u, starting from lowest depth
    :param graph: the graph to perform dfs_visit on
    :param u: the vertex to recurse down
    :param time: the time called
    :return: the time after dfs_visit() completes on the source vertex
    """
    status[u] = 1  # update u to grey
    time += 1

    for v in graph.adjacency_list[u]:
        if status[v] == 0:
            dfs_visit(graph, v, time, status, topological_list)
    status[u] = 2
    time += 1
    topological_list.insert_first(u)


if __name__ == '__main__':
    graph = DirectedGraph()
    graph.add_vertices(["a", "b", "c", "d", "e", "f"])
    graph.add_edges([("a", "b"), ("a", "d"), ("b", "e"), ("c", "f"),
                     ("d", "b"), ("f", "d")])
    print(graph)
    print(topological_sort(graph))
# -*- coding: utf-8 -*-
"""
Created on Tue Jan  7 23:02:05 2020

@author: erick
"""
from DirectedGraph import DirectedGraph

graph = DirectedGraph(8)
graph.addEdge(0, 1, 1)
graph.addEdge(1, 2, 4)
graph.addEdge(1, 3, 3)
graph.addEdge(2, 3, 3)
graph.addEdge(2, 4, 2)
graph.addEdge(2, 5, 5)
graph.addEdge(4, 5, 2)
graph.addEdge(4, 6, 6)
graph.addEdge(5, 6, 1)

graph.addEdge(7, 0, 2)
graph.addEdge(7, 1, 4)
graph.addEdge(7, 3, 8)

distances = graph.altDijkstra(7)
for i in range(len(distances)):
    print("node:", i, "distance", distances[i])
Esempio n. 19
0
#!/usr/bin/env python3

# Name: Kyle Aure
# Course: CS440
# Date: 07/23/2019 
#####  DESCRIPTION  #####
# This file hosts graphs for
# examples and testing

from DirectedGraph import DirectedGraph

emptyGraph = DirectedGraph(0)
cyclicGraph = DirectedGraph(7)
nonCyclicGraph = DirectedGraph(13)
cyclicGraph.graph = {
    0:[1,2,6],
    1:[3],
    2:[1],
    3:[2,4,5],
    4:[],
    5:[0,4],
    6:[4]
}
nonCyclicGraph.graph = {
    0:[5,6,1],
    1:[],
    2:[0,3],
    3:[5],
    4:[],
    5:[4],
    6:[4,9],
Esempio n. 20
0
    def test_get_graph_from_file(self):
        with open("graph.txt", "r") as f:
            firstLine = f.readline()
            firstLine = firstLine.split()
            nrVertices = int(firstLine[0])
            nrEdges = int(firstLine[1])

        graph = DirectedGraph(nrVertices, nrEdges)
        graph.getGraphFromFile("graph.txt")
        graph.writeGraphToFile("graphOut.txt")
        vertices = graph.parseVertices()
        for vertex in vertices:
            print(vertex)
            print(graph.parseNin(vertex))
            print(graph.parseNout(vertex))
            print("\n")

        edges = graph.parseEdges()
        for edge in edges:
            print(str(edge) + " - " + str(edges[edge]))

        self.assertEqual(nrVertices, 5)
        self.assertEqual(graph.isEdge(1, 2), 1)
        self.assertEqual(graph.isEdge(0, 4), 0)

        self.assertEqual(graph.getInDegree(1), 2)
        self.assertEqual(graph.getOutDegree(3), 0)

        self.assertEqual(graph.parseOutboundEdges(0), [(0, 0), (0, 1)])

        self.assertEqual(graph.parseInboundEdges(1), [(0, 1), (2, 1)])

        graph.removeEdge((0, 1))
        self.assertEqual(graph.getNrEdges(), 5)
        self.assertEqual(graph.parseOutboundEdges(0), [(0, 0)])
        self.assertEqual(graph.parseInboundEdges(1), [(2, 1)])

        graph.addEdge(0, 1, 7)

        graph.removeVertex(2)
        self.assertEqual(graph.getNrEdges(), 3)
        self.assertEqual(graph.getNrVertices(), 4)

        print("\n")
        for vertex in vertices:
            print(vertex)
            print(graph.parseNin(vertex))
            print(graph.parseNout(vertex))
            print("\n")

        edges = graph.parseEdges()
        for edge in edges:
            print(str(edge) + " - " + str(edges[edge]))

        self.assertEqual(graph.getCost((0, 1)), 7)

        graph.modifyCost((0, 1), 5)
        self.assertEqual(graph.getCost((0, 1)), 5)

        copyOfGraph = graph.copyGraph()
        copyOfGraph.modifyCost((0, 1), 7)

        self.assertEqual(copyOfGraph.getCost((0, 1)), 7)
        self.assertEqual(graph.getCost((0, 1)), 5)

        randomGraph = graph.randomGraph(10, 14)
        randomGraph.writeGraphToFile("randomgraph.txt")
Esempio n. 21
0
    visited[vtx] = True

    for i in graph.adjacent(vtx):
        if not visited[i]:
            top_util(graph,i,visited,stack)
    stack.append(vtx)


def topological_sort(graph):
    visited = [False]*len(graph.nodes)
    stack = []

    for i in graph.nodes:
        if not visited[i]:
            top_util(graph,i,visited,stack)
    return list(reversed(stack))


inf = float('inf')
adj_mat = [
            [0,inf,inf,inf,inf,inf],
            [inf,0,inf,inf,inf,inf],
            [inf,inf,0,1,inf,inf],
            [inf,1,inf,0,inf,inf],
            [1,1,inf,inf,0,inf],
            [1,inf,1,inf,inf,0]
            ]
so =  topological_sort(DirectedGraph(adj_mat))
print(so )
print(so == [5, 4, 2, 3, 1, 0])
Esempio n. 22
0
from Main import createRandomDAGIter
from DirectedGraph import DirectedGraph
from TopSort import *

ignore = True  # To ignore invalid paths where a node does not exist

x = DirectedGraph()
for char in "ABCDEFGH":
    x.addNode(char)

x.addDirectedEdge(x.getNode("A"), x.getNode("B"))
x.addDirectedEdge(x.getNode("A"), x.getNode("D"))

x.addDirectedEdge(x.getNode("C"), x.getNode("D"))
x.addDirectedEdge(x.getNode("C"), x.getNode("G"))
x.addDirectedEdge(x.getNode("C"), x.getNode("H"))

x.addDirectedEdge(x.getNode("D"), x.getNode("G"))

x.addDirectedEdge(x.getNode("H"), x.getNode("E"))
x.addDirectedEdge(x.getNode("H"), x.getNode("F"))

graphs = [createRandomDAGIter(5), createRandomDAGIter(50), x]

if __name__ == "__main__":
    for g in graphs:
        print(g)
        print()
        for func in [TopSort.Kahns, TopSort.mDFS]:
            arr = func(g)
            print("Node Count: {} | {}".format(len(arr), arr))
#Me - 6
from DirectedGraph import DirectedGraph
from GraphValidator import GraphValidator
from Controller import Controller
from UI import UI

graph = DirectedGraph()
validator = GraphValidator()
ctrl = Controller(graph, validator)
ui = UI(ctrl)

ui.runGraph()
#9 + 2, 9, 3*10
Esempio n. 24
0
        self.visited = [False] * len(graph)
        transpose_graph = [None] * len(graph)

        for vertex in range(len(graph)):
            if not self.visited[vertex]:
                self.transpose_util(vertex, transpose_graph)
        return transpose_graph

    @staticmethod
    def display_graph(graph):
        for v in range(len(graph)):
            print(v, " --> ", end=" ")
            if graph[v] is not None:
                for adj_v in graph[v]:
                    print(adj_v, end=" ")
            print()


g = DirectedGraph(6)
g.add_edge(5, 2)
g.add_edge(5, 0)
g.add_edge(4, 0)
g.add_edge(4, 1)
g.add_edge(2, 3)
g.add_edge(3, 1)
TransposeGraph().display_graph(g.get_graph())
print("Transposed ---> ")
obj = TransposeGraph()
trans = obj.transpose(g.get_graph())
obj.display_graph(trans)
Esempio n. 25
0
    :return: the time after dfs_visit() completes on the source vertex
    """
    status[u] = 1  # update u to grey
    time += 1
    discovery_time[u] = time

    for v in graph.adjacency_list[u]:
        if status[v] == 0:
            parent[v] = u
            time = dfs_visit(graph, v, time, status, discovery_time,
                             finish_time, parent)
    status[u] = 2
    time += 1
    finish_time[u] = time
    return time


if __name__ == '__main__':
    graph1 = DirectedGraph()
    graph1.add_vertices([1, 2, 3, 4, 5, 6, 7])
    graph1.add_edges([(1, 2), (1, 4), (1, 7), (2, 3), (2, 4), (3, 1), (3, 4),
                      (5, 4), (5, 6), (6, 3), (6, 5), (7, 1), (7, 4)])
    print(graph1)
    print(str(dfs(graph1)) + "\n")

    graph2 = DirectedGraph()
    graph2.add_vertices(["a", "b", "c", "d", "e", "f"])
    graph2.add_edges([("a", "b"), ("a", "d"), ("b", "e"), ("c", "f"),
                      ("d", "b"), ("e", "d"), ("f", "d"), ("f", "f")])
    print(graph2)
    print(dfs(graph2))
Esempio n. 26
0
from DirectedGraph import DirectedGraph


def bfs(graph, source):
    visited = [False] * len(graph.nodes)
    visited[source] = True
    bfs_list = []
    queue = [source]

    while queue:
        s = queue.pop(0)
        bfs_list.append(s)

        for vtx in graph.adjacent(s):
            if not visited[vtx]:
                visited[vtx] = True
                queue.append(vtx)
    return bfs_list


inf = float("inf")
adj_mat = [[0, 1, 1, inf], [inf, 0, 1, inf], [1, inf, 0, 1],
           [inf, inf, inf, 0]]
search = bfs(DirectedGraph(adj_mat), 2)
print(search)
print(search == [2, 0, 3, 1])
Esempio n. 27
0
    def topological_sort(self, graph):
        visited = [False] * len(graph)
        stack = []
        # iterate through all the vertices to ensure disconnected vertices are included
        for vertex in range(len(graph)):
            # condition is important to not visit redundant vertices (i.e vertices
            # that are already in the recursion stack)
            if not visited[vertex]:
                self.topological_sort_util(graph, vertex, visited, stack)
        print("Topological sorted order of vertices: ", stack)

    def topological_sort_util(self, graph, source, visited, stack):
        visited[source] = True
        if graph[source]:
            for adj_vertex in graph[source]:
                if not visited[adj_vertex]:
                    self.topological_sort_util(graph, adj_vertex, visited,
                                               stack)
        stack.insert(0, source)


g = DirectedGraph(6)
g.add_edge(5, 2)
g.add_edge(5, 0)
g.add_edge(4, 0)
g.add_edge(4, 1)
g.add_edge(2, 3)
g.add_edge(3, 1)
TopologicalSort().topological_sort(g.adj_list)
    queue.enqueue(source)

    while not queue.is_empty():
        r = queue.dequeue()
        for node in r.links:
            if node.visited is False:
                print(node, target)
                if node == target:
                    return True
                node.visited = True
                queue.enqueue(node)
    return False


if __name__ == '__main__':
    g = DirectedGraph()

    a = g.add_node('A')
    b = g.add_node('B')
    c = g.add_node('C')
    d = g.add_node('D')
    e = g.add_node('E')
    f = g.add_node('F')

    a.points_to(b)
    a.points_to(f)

    b.points_to(d)
    b.points_to(e)

    c.points_to(b)
Esempio n. 29
0
#Prijesh Dholaria
# CS 435 Section 6
# Question 4

from DirectedGraph import DirectedGraph
import random

class Main
    def createRandomDAGIter(n)
        g = DirectedGraph()
        d = {}
        for num in range (n)
            g.addNode(num)
        
        nodes = g.getAllNodes()
        for node in nodes
            numofNodes = random.randint()
            numsinList= [];
            while len(numsinList)!= numofNodes
                num = random.randint(1, nn)
                if num not in numsinList
                    numsinList.append(num)
                    graph.addDirectedEdge(node, num)
        return g;
                    
        
Esempio n. 30
0
        while queue:
            v = queue.pop(0)
            if graph[v]:
                for adj_v in graph[v]:
                    if color[adj_v] == color[v]:
                        return False
                    if color[adj_v] is None:
                        queue.append(adj_v)
                        color[
                            adj_v] = "red" if color[v] == "black" else "black"

        return True


g = DirectedGraph(6)
g.add_edge(0, 2)
g.add_edge(2, 0)
g.add_edge(1, 2)
g.add_edge(0, 3)
g.add_edge(0, 4)
g.add_edge(0, 5)
g.add_edge(4, 5)
# g.add_edge(2, 3)
obj = BipartiteGraph()
# print(obj.is_bipartite(g.get_graph(), 0))

lst = [[2, 4], [2, 3, 4], [0, 1], [1], [0, 1], [7],
       [9], [5], [], [6], [12, 14], [], [10], [], [10], [19], [18], [], [16],
       [15], [23], [23], [], [20, 21], [], [], [27], [26], [], [], [34],
       [33, 34], [], [31], [30, 31], [38, 39], [37, 38, 39], [36], [35, 36],
Esempio n. 31
0
    def _depth_first_search(self, graph, source):
        self._marked[source] = True
        for neighbor in graph.adj(source):
            if not self._marked[neighbor]:
                self._depth_first_search(graph, neighbor)

    # Check if a vertex is reachable from the source
    def reachable(self, vertex):
        return self._marked[vertex]


if __name__ == "__main__":
    argc = len(argv)
    file_name = argv[1]
    sources = Bag()
    for i in range(2, argc):
        sources.add(int(argv[i]))

    graph = DirectedGraph.read_file(file_name)
    vertex_num = graph.vertex_num()
    path = DFSDirectedGraph(graph)
    path.search_mulitple_sources(graph, sources)

    print("The graph: ")
    print(graph)

    for vertex in range(0, vertex_num):
        if path.reachable(vertex):
            print(vertex, end=" ")

    print()
Esempio n. 32
0
def createRandomDAGIter(n : int) -> DirectedGraph:
  return populateGraph(DirectedGraph(), n)