Your sum v1 + (incident edges) + v2 + (incident edges) + …. + vn + (incident edges) can be rewritten as (v1 + v2 + … + vn) + [(incident_edges v1) + (incident_edges v2) + … + (incident_edges vn)] and the first group is O(N) while the other is O(E).
I like this algorithm: def connected_components(neighbors): seen = set() def component(node): nodes = set([node]) while nodes: node = nodes.pop() seen.add(node) nodes |= neighbors[node] – seen yield node for node in neighbors: if node not in seen: yield component(node) Not only is it short and elegant, but also fast. Use it like so (Python 2.7): old_graph … Read more
That heavily depends on the structure of the search tree and the number and location of solutions (aka searched-for items). If you know a solution is not far from the root of the tree, a breadth first search (BFS) might be better. If the tree is very deep and solutions are rare, depth first search … Read more
You can use pos attribute (https://www.graphviz.org/doc/info/attrs.html#d:pos), e.g.: xxx [ label = xxx pos = “0,0!” ] yyy [ label = yyy pos = “10,10!” ] You will also have to specify neato or fdp layout engine, so that dot command-line would be (for fdp): dot -Kfdp -n -Tpng -o sample.png sample.dot
Breadth-first search traverses a graph and in fact finds all paths from a starting node. Usually, BFS doesn’t keep all paths, however. Instead, it updates a prededecessor function π to save the shortest path. You can easily modify the algorithm so that π(n) doesn’t only store one predecessor but a list of possible predecessors. Then … Read more
These are the connected components of a graph, and can be found using a graphing library such as networkx. For your second example: >>> edges = [(1, 5), (4, 2), (4, 3), (5, 4), (6, 3), (7, 6), (8, 9)] >>> graph = nx.Graph(edges) >>> [tuple(c) for c in nx.connected_components(graph)] [(1, 2, 3, 4, 5, … Read more
If you notice, there is a distinct pattern to the adjacency matrices you are creating. Specifically, they are symmetric and banded. You can take advantage of this fact to easily create your matrices using the diag function (or the spdiags function if you want to make a sparse matrix). Here is how you can create … Read more
I was able to prove this with graph-theory. Might want to add that tag in 🙂 Create a graph with n vertices. Create an edge from node n_i to n_j if the element in position i should be in position j in the correct ordering. You will now have a graph consisting of several non-intersecting … Read more
Everyone else comparing this to the Travelling Salesman Problem probably hasn’t read your question carefully. In TSP, the objective is to find the shortest cycle that visits all the vertices (a Hamiltonian cycle) — it corresponds to having every node labelled ‘mustpass’. In your case, given that you have only about a dozen labelled ‘mustpass’, … Read more
Recall that in Dijkstra’s algorithm, once a vertex is marked as “closed” (and out of the open set) – the algorithm found the shortest path to it, and will never have to develop this node again – it assumes the path developed to this path is the shortest. But with negative weights – it might … Read more