Напишите пожалуйста код на python

def find_cycle(adj_list):
visited = [False] * (len(adj_list) + 1)
stack = []
cycle = []

def dfs(u):
visited[u] = True
stack.append(u)

for v in adj_list[u]:
if not visited[v]:
if dfs(v):
return True
elif v in stack:
cycle.extend(stack[stack.index(v):])
return True

stack.pop()
return False

for u in range(1, len(adj_list) + 1):
if not visited[u]:
if dfs(u):
return cycle

return []


if __name__ == "__main__":
n, m = map(int, input().split())
adj_list = [[] for _ in range(n + 1)]

for _ in range(m):
u, v = map(int, input().split())
adj_list[u].append(v)

cycle = find_cycle(adj_list)

if cycle:
print("YES")
print(" ".join(map(str, cycle)))
else:
print("NO")

Для решения задачи определения циклов в ориентированном графе можно использовать алгоритм поиска в глубину (DFS). Если во время выполнения DFS мы обнаружим ребро, которое ведет к вершине, которую мы уже посещали и которая находится в стеке рекурсии, это означает, что найден цикл.

код на Python для решения этой задачи:

 def find_cycle(n, edges): 
    from sys import setrecursionlimit, stdin, stdout 
    import threading 
    setrecursionlimit(100000) 
    threading.stack_size(2**26) 
 
    def dfs(v): 
        nonlocal cycle_start, cycle_end 
        visited[v] = 1 
        stack[v] = 1 
        for to in adj[v]: 
            if visited[to] == 0: 
                parent[to] = v 
                if dfs(to): 
                    return True 
            elif stack[to] == 1: 
                cycle_end = v 
                cycle_start = to 
                return True 
        stack[v] = 0 
        return False 
 
    def solve(): 
        nonlocal cycle_start, cycle_end 
        input = stdin.read 
        data = input().split() 
         
        n = int(data[0]) 
        m = int(data[1]) 
         
        adj = [[] for _ in range(n + 1)] 
        index = 2 
        for _ in range(m): 
            u = int(data[index]) 
            v = int(data[index + 1]) 
            adj[u].append(v) 
            index += 2 
         
        visited = [0] * (n + 1) 
        stack = [0] * (n + 1) 
        parent = [-1] * (n + 1) 
        cycle_start = -1 
        cycle_end = -1 
 
        for v in range(1, n + 1): 
            if visited[v] == 0: 
                if dfs(v): 
                    break 
         
        if cycle_start == -1: 
            print("NO") 
        else: 
            print("YES") 
            cycle = [] 
            cycle.append(cycle_start) 
            v = cycle_end 
            while v != cycle_start: 
                cycle.append(v) 
                v = parent[v] 
            cycle.append(cycle_start) 
            cycle.reverse() 
            print(" ".join(map(str, cycle))) 
 
    threading.Thread(target=solve).start() 
 
# Example usage: 
# You can provide the input directly to the standard input (stdin) or use input redirection from a file. 
import sys 
from io import StringIO 
 
input_data = """3 3 
1 2 
2 3 
3 1 
""" 
sys.stdin = StringIO(input_data) 
find_cycle(3, 3)