如何检测字典中的循环？

Question

I have the following dictionary with the first number being the node, followed by a tuple consisting of a neighbor and then the edge weight (some nodes have multiple neighbors and weights):

dictionary = {1: [(2, 3), (4, 5), (6, 2)], 2: [(3, -4)], 3: [(8, 4)], 4: [(5, 6)], 5: [(4, -3), (8, 8)], 6: [(7, 3)], 7: [(6, -6), (8, 7)]}

How would I use Depth First Search (DFS) to detect if there is a cycle or not? The dictionary will be changed frequently for testing purposes, so some may have cycles and some may not. I am new to python and do not understand how to implement DFS to check for a cycle or not. I have the following DFS code:

visited = set() # Set to keep track of visited nodes of graph.

def dfs(visited, dictionary, node):  #function for dfs
    if node not in visited:
        print (node)
        visited.add(node)
        for neighbour in dictionary[node]:
            dfs(visited, dictionary, neighbour)

and then I call the function: dfs(visited, dictionary, '1') .

But I get the error KeyError: '1' . I also am unsure how to use this code to detect for a cycle or not.

Answer 1

First we consider the base cases. In this instance, we wish to evaluate whether the graph has a cycle or not. The function should return true when a cycle is detected, and false if no such cycle exists after all edges have been examined.

dictionary = {1: [(2, 3)], 2: [], 3: [(4, 4)], 4: [(3, 6)]}

def DFS(visited, dictionary, node):
    if node in visited:
        return True
    else:
        for neighbour, weight in dictionary[node]:
            if DFS(visited | {node}, dictionary, neighbour):
                return True
        return False

print(f"{DFS(set(), dictionary, 1)=}") # False

Depth first search will examine all paths from a single node, going exploring as far as it can before backtracking. If it encounters a node it has seen before, the search will stop and the function returns true. If all paths from the starting node have been exhausted, it returns false. This will only detect whether node 1 is involved in any cycles.

However, this approach is not enough to detect cycles which does not involve the starting node. In the above example, the DFS will not find the cycle between nodes 3 and 4, as it starts its search from 1.

To fix this, we can write another function which examines all the nodes with the DFS.

def containsCycle(dictionary):
    for node in dictionary.keys():
        if DFS(set(), dictionary, node):
            return True
    return False

print(f"{containsCycle(dictionary)=}") # True

dictionary = {1: [(2, 3), (4, 5), (6, 2)], 2: [(3, -4)], 
              3: [(8, 4)], 4: [(5, 6)], 5: [(4, -3), (8, 8)], 
              6: [(7, 3)], 7: [(6, -6), (8, 7)]}

The dictionary above has a edges to a node 8, without an entry for that node in the dictionary. This will cause an error. To resolve this, we can add a guard clause to our recursive function.

def DFS(visited, dictionary, node):
    if node in visited:
        return True
    elif node not in dictionary: # Guard clause
        return False
    else:
        for neighbour, weight in dictionary[node]:
            if DFS(visited | {node}, dictionary, neighbour):
                return True
        return False