def spanning_forest(M): r""" Return a list of edges of a spanning forest of the bipartite graph defined by `M` INPUT: - ``M`` -- a matrix defining a bipartite graph G. The vertices are the rows and columns, if `M[i,j]` is non-zero, then there is an edge between row `i` and column `j`. OUTPUT: A list of tuples `(r_i,c_i)` representing edges between row `r_i` and column `c_i`. EXAMPLES:: sage: len(sage.matroids.utilities.spanning_forest(matrix([[1,1,1],[1,1,1],[1,1,1]]))) 5 sage: len(sage.matroids.utilities.spanning_forest(matrix([[0,0,1],[0,1,0],[0,1,0]]))) 3 """ # Given a matrix, produce a spanning tree G = Graph() m = M.ncols() for (x, y) in M.dict(): G.add_edge(x + m, y) T = [] # find spanning tree in each component for component in G.connected_components(): spanning_tree = kruskal(G.subgraph(component)) for (x, y, z) in spanning_tree: if x < m: t = x x = y y = t T.append((x - m, y)) return T
def spanning_forest(M): r""" Return a list of edges of a spanning forest of the bipartite graph defined by `M` INPUT: - ``M`` -- a matrix defining a bipartite graph G. The vertices are the rows and columns, if `M[i,j]` is non-zero, then there is an edge between row `i` and column `j`. OUTPUT: A list of tuples `(r_i,c_i)` representing edges between row `r_i` and column `c_i`. EXAMPLES:: sage: len(sage.matroids.utilities.spanning_forest(matrix([[1,1,1],[1,1,1],[1,1,1]]))) 5 sage: len(sage.matroids.utilities.spanning_forest(matrix([[0,0,1],[0,1,0],[0,1,0]]))) 3 """ # Given a matrix, produce a spanning tree G = Graph() m = M.ncols() for (x,y) in M.dict(): G.add_edge(x+m,y) T = [] # find spanning tree in each component for component in G.connected_components(): spanning_tree = kruskal(G.subgraph(component)) for (x,y,z) in spanning_tree: if x < m: t = x x = y y = t T.append((x-m,y)) return T
def strong_orientations_iterator(G): r""" Returns an iterator over all strong orientations of a graph `G`. A strong orientation of a graph is an orientation of its edges such that the obtained digraph is strongly connected (i.e. there exist a directed path between each pair of vertices). ALGORITHM: It is an adaptation of the algorithm published in [CGMRV16]_. It runs in `O(mn)` amortized time, where `m` is the number of edges and `n` is the number of vertices. The amortized time can be improved to `O(m)` with a more involved method. In this function, first the graph is preprocessed and a spanning tree is generated. Then every orientation of the non-tree edges of the graph can be extended to at least one new strong orientation by orienting properly the edges of the spanning tree (this property is proved in [CGMRV16]_). Therefore, this function generates all partial orientations of the non-tree edges and then launches a helper function corresponding to the generation algorithm described in [CGMRV16]_. In order to avoid trivial symetries, the orientation of an arbitrary edge is fixed before the start of the enumeration process. INPUT: - ``G`` -- an undirected graph. OUTPUT: - an iterator which will produce all strong orientations of this graph. .. NOTE:: Works only for simple graphs (no multiple edges). In order to avoid symetries an orientation of an arbitrary edge is fixed. EXAMPLES: A cycle has one possible (non-symmetric) strong orientation:: sage: g = graphs.CycleGraph(4) sage: it = g.strong_orientations_iterator() sage: len(list(it)) 1 A tree cannot be strongly oriented:: sage: g = graphs.RandomTree(100) sage: len(list(g.strong_orientations_iterator())) 0 Neither can be a disconnected graph:: sage: g = graphs.CompleteGraph(6) sage: g.add_vertex(7) sage: len(list(g.strong_orientations_iterator())) 0 TESTS: sage: g = graphs.CompleteGraph(2) sage: len(list(g.strong_orientations_iterator())) 0 sage: g = graphs.CubeGraph(3) sage: b = True sage: for orientedGraph in g.strong_orientations_iterator(): ....: if not orientedGraph.is_strongly_connected(): ....: b = False sage: b True The total number of strong orientations of a graph can be counted using the Tutte polynomial evaluated at points (0,2):: sage: g = graphs.PetersenGraph() sage: nr1 = len(list(g.strong_orientations_iterator())) sage: nr2 = g.tutte_polynomial()(0,2) sage: nr1 == nr2/2 # The Tutte polynomial counts also the symmetrical orientations True """ # if the graph has a bridge or is disconnected, # then it cannot be strongly oriented if G.order() < 3 or not G.is_biconnected(): return V = G.vertices() Dg = DiGraph([G.vertices(), G.edges()], pos=G.get_pos()) # compute an arbitrary spanning tree of the undirected graph te = kruskal(G) treeEdges = [(u,v) for u,v,_ in te] A = [edge for edge in G.edges(labels=False) if edge not in treeEdges] # initialization of the first binary word 00...0 # corresponding to the current orientation of the non-tree edges existingAedges = [0]*len(A) # Make the edges of the spanning tree doubly oriented for e in treeEdges: if Dg.has_edge(e): Dg.add_edge(e[1], e[0]) else: Dg.add_edge(e) # Generate all orientations for non-tree edges (using Gray code) # Each of these orientations can be extended to a strong orientation # of G by orienting properly the tree-edges previousWord = 0 i = 0 # the orientation of one edge is fixed so we consider one edge less nr = 2**(len(A)-1) while i < nr: word = (i >> 1) ^ i bitChanged = word ^ previousWord bit = 0 while bitChanged > 1: bitChanged >>= 1 bit += 1 previousWord = word if existingAedges[bit] == 0: Dg.reverse_edge(A[bit]) existingAedges[bit] = 1 else: Dg.reverse_edge(A[bit][1], A[bit][0]) existingAedges[bit] = 0 # launch the algorithm for enumeration of the solutions for sol in _strong_orientations_of_a_mixed_graph(Dg, V, treeEdges): yield sol i = i + 1