Python Graph.add_edge方法代码示例

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_set_edge_value_works_for_undirected_graphs(self):
        g = Graph(False)
        g.add_edge((1,2,10))
        g.set_edge_value((1,2), 30)

        self.assertEqual(g.table[1][2], 30, 'has updated the edge')
        self.assertEqual(g.table[2][1], 30, 'reverse edge was updated too')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_set_edge_value_if_edge_exists(self):
        g = Graph(True)
        g.add_edge((1,2,10))
        g.set_edge_value((1,2), 20)

        self.assertEqual(g.table[1][2], 20,
                'should have updated the edge value')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_get_vertices_for_directed_graph(self):
        g = Graph(True)
        g.add_edge((1,2))

        actual = g.get_vertices()
        expected = [1,2]
        self.assertEqual(actual, expected, 'should return all vertices')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
class ReverseDelete(object):
    name = 'reversedelete'

    def __init__(self, save_all_edges=False):
        self.queue = PriorityQueue()
        self.graph = Graph()
        self.logging = False
        self.save_all_edges = save_all_edges
        self.all_edges = []
    
    def set_logging(self, level):
        if level == 'debug':
            self.logging = True

    def add_edge(self, node1, node2, weight, n, n_nodes, n_edges):
        self.queue.put((-weight, (node1, node2)))
        if self.save_all_edges:
            self.all_edges.append((node1, node2, weight))

    def init_from_file(self, f):
        self.graph.import_data(f, self.add_edge)

    def solve(self):
        res = []
        while not self.queue.empty():
            (weight, edge) = self.queue.get()
            self.graph.remove_edge(edge[0], edge[1])
            if not self.graph.is_connected():
                self.graph.add_edge(edge[0], edge[1], -weight)
                res.append((edge[0], edge[1], -weight))
                continue
        
        return (self.graph.n_nodes, len(res), res)

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_set_edge_value_if_graph_is_directed_and_inverse_edge_exists(self):
        g = Graph(True)
        g.add_edge((1,2,10))
        g.add_edge((2,1,20))
        g.set_edge_value((1,2), 30)

        self.assertEqual(g.table[1][2], 30, 'has updated the edge')
        self.assertEqual(g.table[2][1], 20, 'reverse edge remained the same')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_get_edge_value_in_directed_graph(self):
        g = Graph(True)
        g.add_edge((1,2,3))

        self.assertEqual(g.get_edge_value((1,2)), 3,
                'should have stored value')
        self.assertIsNone(g.get_edge_value((2,1)),
                'should have no value for reverse edge')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_incident_in_directed_graph(self):
        g = Graph(directed = True)
        g.add_edge((2,1))
        g.add_edge((3,1))

        actual = g.incident(1)
        expected = [2, 3]
        self.assertEqual(actual, expected, '1 has two incident vertexes')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_add_edge_multiple_times_nothing_happens(self):
        g = Graph(True)
        g.add_edge((1,2,3))
        g.add_edge((1,2,3))
        g.add_edge((1,2,3))
        g.add_edge((1,2,3))

        self.assertIn(1, g.table, 'should have stored the tail in table')
        self.assertIn(2, g.table[1], 'should have stored the head in table')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_egress(self):
        g = Graph(False)
        g.add_edge((1, 2, 10))
        g.add_edge((1, 3, 11))
        g.add_edge((2, 3, 12))

        actual = g.egress(1)
        expected = [(1, 2, 10), (1, 3, 11)]
        self.assertEqual(actual, expected, 'should return ingress edges')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
def constructor(M, sigma, kind='log'):
    g = Graph()
    for i in range(len(M)):
        for j in range(len(M[i])):
            for p in range(len(M)):
                for q in range(len(M[i])):
                    if p != i or q != j:
                        g.add_edge(get_name(i, j), get_name(p, q), weight(M, [i, j], [p, q], kind, sigma))
    g.normalize()
    return g

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_remove_edge_in_directed_graph(self):
        g = Graph(True)
        g.add_edge((1,2,10))
        g.add_edge((2,3,11))
        g.add_edge((3,1,12))

        g.remove_edge((2,3))
        self.assertEqual(g.table[1][2], 10, 'should have kept the edge')
        self.assertEqual(g.table[3][1], 12, 'should have kept the edge')
        self.assertEqual(g.table[2], {}, 'should have removed the edge')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_add_edge_for_directed_graph(self):
        g = Graph(True)
        g.add_edge((1,2,3))

        self.assertIn(1, g.table, 'should have stored a key for tail vertex')
        self.assertIn(2, g.table[1], 'should have stored the edge')
        self.assertEqual(g.table[1][2], 3, 'should have stored the edge value')

        self.assertIn(2, g.table, 'should not have stored the node')
        self.assertNotIn(1, g.table[2], 'should not have stored the reverse edge')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_get_vertices_for_undirected_graph(self):
        g = Graph(False)
        g.add_edge((1,2))
        g.add_edge((2,3))
        g.add_edge((3,1))

        actual = g.get_edges()
        expected = [(1,2,True), (1,3,True), (2,3,True)]

        self.assertEqual(actual, expected, 'should return only one way edges')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_add_edge_for_undirected_graph(self):
        g = Graph(False)
        g.add_edge((1,2,3))

        self.assertIn(1, g.table, 'should have stored a key for tail vertex')
        self.assertIn(2, g.table[1], 'should have stored the edge')
        self.assertEqual(g.table[1][2], 3, 'should have stored the edge value')

        self.assertIn(2, g.table, 'should have stored a key for head vertex')
        self.assertIn(1, g.table[2], 'should have stored the reversed edge')
        self.assertEqual(g.table[2][1], 3, 'should have stored the edge value')

# 需要导入模块: from src.graph import Graph [as 别名]
# 或者: from src.graph.Graph import add_edge [as 别名]
    def test_remove_vertex(self):
        g = Graph(False)
        g.add_edge((1,2))
        g.add_edge((2,3))
        g.add_edge((3,1))

        g.remove_vertex(3)

        self.assertTrue(g.table[1][2], 'should keep edges not involving 3')
        self.assertTrue(g.table[2][1], 'should keep edges not involving 3')
        self.assertNotIn(3, g.table, 'vertex 3 disappeared')
        self.assertNotIn(3, g.table[1], 'edge from 3 to 1 dissappeared')