Hello and welcome to the next lesson of our course, "Solving Algorithmic Problems with DFS." In previous lessons, we introduced Graphs and their representations, venturing into one of the most predominant procedures in Graph theory — Depth-First Search. Today, we'll learn how to use Depth-First Search to solve a common problem: determining if there is a cycle in the graph.

Detecting cycles in a graph is a common problem that has applications in various domains. It is particularly useful in network routing, deadlock detection in operating systems, and in mathematical problems such as finding the presence of loops in a mathematical sequence.

In a graph, a cycle exists if we can start at a node, traverse along the edges, and return to the same node without retracing any edge. Our task is to construct a DFS function has_cycle(graph), which will check for a cycle in the given graph and return true if a cycle is found and false if the graph is acyclic.

Graphs can be represented in multiple ways, but for this lesson, we will use adjacency list representation for simplicity and efficiency.

The solution to this problem requires, first and foremost, implementing the DFS function. In this function, we mark the current node as visited and then check for each adjacent node. If the adjacent node is visited and it is not the parent of the current node, we find a cycle and return true. If the adjacent node is not visited, we recursively call the DFS function for that node.

Here is the modified dfs function for this task:

def dfs(vertex, visited, graph, parent):
    visited.add(vertex)
    for neighbor in graph[vertex]: 
        if neighbor not in visited: 
            if dfs(neighbor, visited, graph, vertex): 
                return True
        elif neighbor != parent:
            # The parent is already visited, but the parent -> vertex -> parent cycle is degenerate
            return True
    return False

The function adds the current vertex to visited nodes. It then explores neighbors of vertex. If the neighbor was not visited before, the function recursively visits the neighbor, specifying vertex as its parent. If the neighbor is already in the visited and it is not the parent of the current vertex, it means that a cycle has been found, and it returns True. If all the neighbor nodes are explored without finding a cycle, it returns False (indicating no cycle found from the vertex).