class Graph:
    def __init__(self, vertices):
        self.vertices = vertices
        self.graph = {}
 
    def add_edge(self, u, v):
        if u not in self.graph:
            self.graph[u] = []
        self.graph[u].append(v)
 
    def is_cyclic_util(self, v, visited, rec_stack):
        visited[v] = True
        rec_stack[v] = True
 
        if v in self.graph:
            for neighbor in self.graph[v]:
                if not visited[neighbor]:
                    if self.is_cyclic_util(neighbor, visited, rec_stack):
                        return True
                elif rec_stack[neighbor]:
                    return True
 
        rec_stack[v] = False
        return False
 
    def is_cyclic(self):
        visited = {v: False for v in range(self.vertices)}
        rec_stack = {v: False for v in range(self.vertices)}
 
        for vertex in range(self.vertices):
            if not visited[vertex]:
                if self.is_cyclic_util(vertex, visited, rec_stack):
                    return True
 
        return False
 
 
# Приклад використання
if __name__ == "__main__":
    # Створення графа та додавання ребер
    g = Graph(4)
    g.add_edge(0, 1)
    g.add_edge(0, 2)
    g.add_edge(1, 2)
    g.add_edge(2, 0)
    g.add_edge(2, 3)
    g.add_edge(3, 3)
 
    # Перевірка, чи є граф ациклічним
    if g.is_cyclic():
        print("Граф містить цикли.")
    else:
        print("Граф є ациклічним.")
 

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