计算有向图中长度为 n 的循环数

Question

I have searched for a while and found multiple algorithms to detect cycle in directed graphs, but I am interested to determine the length of cycle.

on the other hand there is also algorithm that works only for undirected graphs here .

def DFS(V, graph, marked, n, vert, start, count):
    """
    Python Program to count cycles of length n in a given graph.
    """

    # mark the vertex vert as visited
    marked[vert] = True

    # if the path of length (n-1) is found
    if n == 0:

        # mark vert as un-visited to make it usable again.
        marked[vert] = False

        # Check if vertex vert can end with vertex start
        if graph[vert][start] == 1:
            count = count + 1
            return count
        else:
            return count

    # For searching every possible path of length (n-1)
    for i in range(V):
        if marked[i] == False and graph[vert][i] == 1:

            # DFS for searching path by decreasing length by 1
            count = DFS(V, graph, marked, n-1, i, start, count)

    # marking vert as unvisited to make it usable again.
    marked[vert] = False
    return count


def countCycles(graph, n, V):
    '''Counts cycles of length N in an undirected
    and connected graph.
    '''

    # all vertex are marked un-visited initially.
    marked = [False] * V

    # Searching for cycle by using v-n+1 vertices
    count = 0
    for i in range(V-(n-1)):
        count = DFS(V, graph, marked, n-1, i, i, count)

        # ith vertex is marked as visited and
        # will not be visited again.
        marked[i] = True

    return int(count/2)

V = 5 # number of vertex
adj0 = np.array([[0, 1, 0, 1, 1],
                 [1, 0, 1, 1, 0],
                 [0, 1, 0, 1, 0],
                 [1, 1, 1, 0, 1],
                 [1, 0, 0, 1, 0]])

for i in [3, 4]:
    print(f"number of cycle with length {i} is" , helpers.countCycles(adj0.tolist(), i, V))

# number of cycle with length 3 is 3
# number of cycle with length 4 is 2

How to combine these to have an algorithm to look for a cycle with determined length?

Answer 1

Start with an adjacency matrix M such that there is a 1 at row j, column i if there is an arc from vertex i to vertex j, and 0 otherwise. Note the ordering -- each vertex's arcs are represented by a column in this matrix, so it's the transpose of the more common row-major order for adjacency matrices.

Now, If we define a vertex vector V _i to be a column vector that has a 1 in row i and 0 everywhere else, then the product MV _i gives the number of ways that you can get from vertex i to every other vertex in one step . The sum of the diagonal elements is the number of length-1 cycles .

Using matrix exponentiation-by-squaring , you can calculate M ⁿ in O(|V| ³ log n) time†. For every vertex vector, then M ⁿ V _i gives the number of ways you can get from vertex i to every other vertex in n steps , and the sum of the diagonal elements of M ⁿ is the total number of length-n cycles .

† - caveat: the O(|V| ³ log n) time assumes constant times for mathematical operations, which is not necessarily true, since the numbers involved can get very large.

Answer 2

Performance note. Set n to be the size of the graph, and you have the Hamiltonian Cycle problem . This is well-known to be NP-complete. Conversely this means that, even if you were told the n points that contain the cycle, verifying that there is a cycle of length n in those points is still hard.

Therefore while producing a correct algorithm isn't that hard, producing an efficient one is a different story.