class Graphe:
    def __init__(self):
        """
        Initialise un graphe vide.

        Le graphe est représenté par un dictionnaire :
        chaque sommet est associé à la liste de ses voisins.
        """
        self.adj = {}

    def ajouter_sommet(self, sommet):
        """
        Ajoute un sommet au graphe s’il n’existe pas déjà.

        Paramètre :
        ----------
        sommet : int
            Le sommet à ajouter.
        """
        if sommet not in self.adj:
            self.adj[sommet] = []

    def ajouter_arc(self, u, v):
        """
        Ajoute un arc orienté du sommet u vers le sommet v.

        Si les sommets n’existent pas, ils sont créés.

        Paramètres :
        -----------
        u : int
            Sommet de départ
        v : int
            Sommet d’arrivée
        """
        self.ajouter_sommet(u)
        self.ajouter_sommet(v)
        if v not in self.adj[u]:
            self.adj[u].append(v)

    def retirer_arc(self, u, v):
        """
        Supprime l’arc u -> v s’il existe.

        Paramètres :
        -----------
        u : int
            Sommet de départ
        v : int
            Sommet d’arrivée
        """
        if u in self.adj and v in self.adj[u]:
            self.adj[u].remove(v)

    def voisins(self, sommet):
        """
        Renvoie la liste des voisins d’un sommet.

        Paramètre :
        ----------
        sommet : int

        Retour :
        -------
        list
            Liste des voisins du sommet.
            Renvoie une liste vide si le sommet n’existe pas.
        """
        if sommet in self.adj:
            return self.adj[sommet]
        return []

    def est_adjacent(self, u, v):
        """
        Indique si un arc u -> v existe dans le graphe.

        Paramètres :
        -----------
        u : int
        v : int

        Retour :
        -------
        bool
            True si l’arc existe, False sinon.
        """
        return u in self.adj and v in self.adj[u]

    def parcours_profondeur(self, depart):
        """
        Effectue un parcours en profondeur (DFS) à partir d’un sommet.

        Paramètre :
        ----------
        depart : int
            Sommet de départ du parcours.

        Retour :
        -------
        list
            Liste des sommets visités dans l’ordre du parcours.
        """
        visites = []

        def dfs(sommet):
            if sommet not in visites:
                visites.append(sommet)
                for voisin in self.adj[sommet]:
                    dfs(voisin)

        if depart in self.adj:
            dfs(depart)

        return visites

    def __str__(self):
        """
        Renvoie une représentation textuelle du graphe.

        Retour :
        -------
        str
            Une chaîne de caractères listant chaque sommet
            et ses voisins.
        """
        resultat = ""
        for sommet in self.adj:
            resultat += str(sommet) + " -> " + str(self.adj[sommet]) + "\n"
        return resultat