Round Robin Cycle Probability

import string, random, pprint

POOL_SIZE = 3;
ITERATIONS = 1000;

def generate_edges(node_count):
    """Generates a dict, where each node is available as a key, and each value is a set of all nodes connected to the
    key node.  e.g. {'a':set(['b','c']),'b':set(['a','c']),'c':set(['a','b'])} is a fully connected unidirectional
    three-node graph.
    """
    edges = {string.ascii_lowercase[i]: set() for i in range(node_count)}
    for i in range(node_count):
        for j in range(i+1,node_count):
            if bool(random.getrandbits(1)):
                i_char = string.ascii_lowercase[i]
                j_char = string.ascii_lowercase[j]
                edges[i_char].add(j_char)
                edges[j_char].add(i_char)
    return edges

def check_inclusive_cycle(first_node, current_node, edges, traversed_nodes, remaining_nodes):
    """Depth-first recursive search to identify if a cycle exists that includes all nodes"""
    assert type(traversed_nodes) is set
    assert type(remaining_nodes) is set
    assert type(edges) is dict
    if not remaining_nodes:
        return first_node in edges[current_node]
    elif edges[current_node] <= traversed_nodes:
        return False
    else:
        for node in edges[current_node] - traversed_nodes:
            if check_inclusive_cycle(first_node, node, edges, traversed_nodes.union(current_node),
                                     remaining_nodes.difference(node)):
                return True
        return False

results = []
for i in range(ITERATIONS):
    generated_edges = generate_edges(POOL_SIZE)
    beginning_node = next(iter(generated_edges))
    pprint.pprint(generated_edges)
    result = check_inclusive_cycle(beginning_node, beginning_node, generated_edges, set(),
                                                     set(generated_edges.keys()).difference(beginning_node))
    results.append(result)
    print(result)

print("{0} cycles found in {1} iterations.".format(sum(results), len(results)))

Python Fiddle

Python Cloud IDE