


'''simple docstring'''

from __future__ import annotations







class 			UpperCAmelCase			:

 def __init__(			self			:						List[str],       a_			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    vertices
    UpperCamelCase__			    =    [[0] * vertices for _ in range(a_       )]

 def 		lowercase_    (			self			:						List[Any],       a_			:						list[int]       ):





    """simple docstring"""



    print("Vertex \t Distance from Source"       )
    for vertex in range(self.vertices       ):
       print(a_,       "\t\t",       distances_from_source[vertex]       )

 def 		lowercase_    (			self			:						List[Any],       a_			:						list[int],       a_			:						list[bool]       ):





    """simple docstring"""



    UpperCamelCase__			    =    1e7
    UpperCamelCase__			    =    0

    # Search not nearest vertex not in the shortest path tree
    for vertex in range(self.vertices       ):
       if distances_from_source[vertex] < minimum and visited[vertex] is False:
          UpperCamelCase__			    =    distances_from_source[vertex]
          UpperCamelCase__			    =    vertex
    return min_index

 def 		lowercase_    (			self			:						Optional[int],       a_			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    [int(1e7       )] * self.vertices  # distances from the source
    UpperCamelCase__			    =    0
    UpperCamelCase__			    =    [False] * self.vertices

    for _ in range(self.vertices       ):
       UpperCamelCase__			    =    self.minimum_distance(a_,       a_       )
       UpperCamelCase__			    =    True

       # Update dist value of the adjacent vertices
       # of the picked vertex only if the current
       # distance is greater than new distance and
       # the vertex in not in the shortest path tree
       for v in range(self.vertices       ):
          if (
              self.graph[u][v] > 0
              and visited[v] is False
              and distances[v] > distances[u] + self.graph[u][v]
          ):
             UpperCamelCase__			    =    distances[u] + self.graph[u][v]

    self.print_solution(a_       )


if __name__ == "__main__":
       __lowercase:		Dict    						=  Graph(9)
       __lowercase:		List[str]    						=  [
           [0, 4, 0, 0, 0, 0, 0, 8, 0],
           [4, 0, 8, 0, 0, 0, 0, 11, 0],
           [0, 8, 0, 7, 0, 4, 0, 0, 2],
           [0, 0, 7, 0, 9, 14, 0, 0, 0],
           [0, 0, 0, 9, 0, 10, 0, 0, 0],
           [0, 0, 4, 14, 10, 0, 2, 0, 0],
           [0, 0, 0, 0, 0, 2, 0, 1, 6],
           [8, 11, 0, 0, 0, 0, 1, 0, 7],
           [0, 0, 2, 0, 0, 0, 6, 7, 0],
       ]
       graph.dijkstra(0)



"""simple docstring"""






def    A_ ( _lowerCAmelCase  :       list[list[int]]							):






     """simple docstring"""

     _a     						=					[list(_lowerCAmelCase							) for row in matrix]
     if matrix and isinstance(_lowerCAmelCase,  _lowerCAmelCase							):
          if isinstance(matrix[0],  _lowerCAmelCase							):
               _a     						=					0
               for row in matrix:
                    if prev_len == 0:
                         _a     						=					len(_lowerCAmelCase							)
                         _a     						=					True
                    else:
                         _a     						=					prev_len == len(_lowerCAmelCase							)
          else:
               _a     						=					True
     else:
          _a     						=					False

     return result
def    A_ ( _lowerCAmelCase  :       list[list[int]]							):






     """simple docstring"""

     if check_matrix(_lowerCAmelCase							) and len(_lowerCAmelCase							) > 0:
          _a     						=					[list(_lowerCAmelCase							) for row in a]
          _a     						=					len(_lowerCAmelCase							)
          if isinstance(a[0],  _lowerCAmelCase							):
               _a     						=					len(a[0]							)
          else:
               for dat in a:
                    print(_lowerCAmelCase							)
               return

          # horizotal printing increasing
          for i in range(0,  _lowerCAmelCase							):
               print(a[0][i]							)
          # vertical printing down
          for i in range(1,  _lowerCAmelCase							):
               print(a[i][mat_col - 1]							)
          # horizotal printing decreasing
          if mat_row > 1:
               for i in range(mat_col - 2,  -1,  -1							):
                    print(a[mat_row - 1][i]							)
        # vertical printing up
          for i in range(mat_row - 2,  0,  -1							):
               print(a[i][0]							)
          _a     						=					[row[1 : mat_col - 1] for row in a[1 : mat_row - 1]]
          if len(_lowerCAmelCase							) > 0:
               spiral_print_clockwise(_lowerCAmelCase							)
          else:
               return
     else:
          print('''Not a valid matrix'''							)
          return
def    A_ ( _lowerCAmelCase  :       list[list]							):






     """simple docstring"""

     if matrix:
          return list(matrix.pop(0							)							) + spiral_traversal(list(zip(*_lowerCAmelCase							)							)[::-1]							)
     else:
          return []


# driver code
if __name__ == "__main__":
   import doctest

   doctest.testmod()

   __snake_case												=							[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
   spiral_print_clockwise(a)