


class A  :






      def __init__(					self						:     int )					->						Any:
             """simple docstring"""




             _lowerCamelCase       :		Any		={}






      def        lowerCamelCase       (					self						:     int )					->						None:
             """simple docstring"""




             print(self.vertex )
             for i in self.vertex:
                    print(lowercase_			,   ' -> '			,   ' -> '.join([str(lowercase_ ) for j in self.vertex[i]] ) )






      def        lowerCamelCase       (					self						:     Optional[Any]			,   lowercase_						:     int			,   lowercase_						:     int )					->						None:
             """simple docstring"""




             if from_vertex in self.vertex:
                    self.vertex[from_vertex].append(lowercase_ )
             else:
                    # else make a new vertex
                    _lowerCamelCase       :		Dict		=[to_vertex]






      def        lowerCamelCase       (					self						:     List[Any] )					->						None:
             """simple docstring"""




             _lowerCamelCase       :		List[Any]		=[False] * len(self.vertex )

             # call the recursive helper function
             for i in range(len(self.vertex ) ):
                    if not visited[i]:
                           self.dfs_recursive(lowercase_			,   lowercase_ )






      def        lowerCamelCase       (					self						:     Any			,   lowercase_						:     int			,   lowercase_						:     list )					->						None:
             """simple docstring"""




             _lowerCamelCase       :		List[str]		=True

             print(lowercase_			,   end=' ' )

             # Recur for all the vertices that are adjacent to this node
             for i in self.vertex:
                    if not visited[i]:
                           self.dfs_recursive(lowercase_			,   lowercase_ )


if __name__ == "__main__":
 lowerCamelCase											=       Graph()
 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)

 g.print_graph()
 print('DFS:')
 g.dfs()

 # OUTPUT:
 # 0  ->  1 -> 2
 # 1  ->  2
 # 2  ->  0 -> 3
 # 3  ->  3
 # DFS:
 #  0 1 2 3






# using dfs for finding eulerian path traversal




def 	a_      (    SCREAMING_SNAKE_CASE__					:      Any		,			SCREAMING_SNAKE_CASE__					:      List[str]		,			SCREAMING_SNAKE_CASE__					:      List[str]		,			SCREAMING_SNAKE_CASE__					:      Optional[int]=None     ):
       '''simple docstring'''





       _lowerCamelCase       :		Optional[Any]		=(path or []) + [u]
       for v in graph[u]:
              if visited_edge[u][v] is False:
                     _lowerCamelCase	,     _lowerCamelCase       :		Dict		=True, True
                     _lowerCamelCase       :		Optional[Any]		=dfs(SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__     )
       return path




def 	a_      (    SCREAMING_SNAKE_CASE__					:      List[str]		,			SCREAMING_SNAKE_CASE__					:      Optional[Any]     ):
       '''simple docstring'''





       _lowerCamelCase       :		Union[str, Any]		=0
       _lowerCamelCase       :		Union[str, Any]		=-1
       for i in range(SCREAMING_SNAKE_CASE__     ):
              if i not in graph.keys():
                     continue
              if len(graph[i]     ) % 2 == 1:
                     odd_degree_nodes += 1
                     _lowerCamelCase       :		Tuple		=i
       if odd_degree_nodes == 0:
              return 1, odd_node
       if odd_degree_nodes == 2:
              return 2, odd_node
       return 3, odd_node




def 	a_      (    SCREAMING_SNAKE_CASE__					:      Union[str, Any]		,			SCREAMING_SNAKE_CASE__					:      Any     ):
       '''simple docstring'''





       _lowerCamelCase       :		Tuple		=[[False for _ in range(max_node + 1     )] for _ in range(max_node + 1     )]
       _lowerCamelCase	,     _lowerCamelCase       :		Optional[int]		=check_circuit_or_path(SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__     )
       if check == 3:
              print('graph is not Eulerian'     )
              print('no path'     )
              return
       _lowerCamelCase       :		Any		=1
       if check == 2:
              _lowerCamelCase       :		Tuple		=odd_node
              print('graph has a Euler path'     )
       if check == 1:
              print('graph has a Euler cycle'     )
       _lowerCamelCase       :		int		=dfs(SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__     )
       print(SCREAMING_SNAKE_CASE__     )




def 	a_      (    ):
       '''simple docstring'''





       _lowerCamelCase       :		Union[str, Any]		={1: [2, 3, 4], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [4]}
       _lowerCamelCase       :		str		={1: [2, 3, 4, 5], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [1, 4]}
       _lowerCamelCase       :		List[Any]		={1: [2, 3, 4], 2: [1, 3, 4], 3: [1, 2], 4: [1, 2, 5], 5: [4]}
       _lowerCamelCase       :		Any		={1: [2, 3], 2: [1, 3], 3: [1, 2]}
       _lowerCamelCase       :		Dict		={
           1: [],
           2: []
           # all degree is zero
       }
       _lowerCamelCase       :		str		=10
       check_euler(SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__     )
       check_euler(SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__     )
       check_euler(SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__     )
       check_euler(SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__     )
       check_euler(SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__     )


if __name__ == "__main__":
 main()


