class Edge: 
    def __init__(self, u, v): 
        self.u = u 
        self.v = v 
 
    def opposite(self, x): 
        if x == self.u: 
            return self.v 
        elif x == self.v: 
            return self.u 
        else: 
            return None 
 
class Graph: 
    def __init__(self, n): 
        self.adj = {i: [] for i in range(1,n+1)} 
 
    def add_edge(self, u, v): 
        e = Edge(u, v) 
        self.adj[u].append(e) 
        self.adj[v].append(e)    
 
    def incident_edges(self, u): 
        return self.adj[u] 
 
    def vertices(self): 
        return self.adj.keys() 
 
def DFS(g, u, forest): 
    for e in g.incident_edges(u): 
        v = e.opposite(u) 
        if v not in forest: 
            forest[v] = e 
            DFS(g, v, forest) 
 
def DFS_complete(g, start): 
    forest = {} 
 
 
 
    forest[start] = None 
    DFS(g, start, forest) 
 
    for u in g.vertices(): 
        if u not in forest: 
            forest[u] = None 
            DFS(g, u, forest) 
 
    return forest 
 
print("\tDepth First Search Tree Traversal\n") 
n = int(input("Enter number of vertices: ")) 
m = int(input("Enter number of edges: ")) 
 
g = Graph(n) 
 
print("Give vertex numbers from 1 to ", n) 
print("Enter edges (u v):") 
for _ in range(m): 
    u, v = map(int, input().split()) 
    g.add_edge(u, v)     
 
start = int(input("Enter starting vertex: ")) 
 
forest = DFS_complete(g, start) 
 
print("\nDFS Tree (vertex : discovered from)") 
for v in forest: 
    if forest[v] is None: 
        print(f"{v} : None (root)") 
    else: 
        parent = forest[v].opposite(v) 
        print(f"{v} : discovered from {parent}")