"""simple docstring"""



from collections import deque



def 					_lowerCamelCase(					a							):
       __a     				=  len(UpperCAmelCase_							)
       __a     				=  deque()
       __a     				=  [False for _ in range(UpperCAmelCase_							)]
       __a     				=  [-1 for _ in range(UpperCAmelCase_							)]
       __a     				=  index_of[:]

       def strong_connect(a ,  a ,  a							):
              __a     				=  index  # the number when this node is seen
              __a     				=  index  # lowest rank node reachable from here
              index += 1
              stack.append(UpperCAmelCase_							)
              __a     				=  True

              for w in g[v]:
                     if index_of[w] == -1:
                            __a     				=  strong_connect(UpperCAmelCase_ ,  UpperCAmelCase_ ,  UpperCAmelCase_							)
                            __a     				=  (
                                lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
                            )
                     elif on_stack[w]:
                            __a     				=  (
                                lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
                            )

              if lowlink_of[v] == index_of[v]:
                     __a     				=  []
                     __a     				=  stack.pop()
                     __a     				=  False
                     component.append(UpperCAmelCase_							)
                     while w != v:
                            __a     				=  stack.pop()
                            __a     				=  False
                            component.append(UpperCAmelCase_							)
                     components.append(UpperCAmelCase_							)
              return index

       __a     				=  []
       for v in range(UpperCAmelCase_							):
              if index_of[v] == -1:
                     strong_connect(UpperCAmelCase_ ,  0 ,  UpperCAmelCase_							)

       return components



def 					_lowerCamelCase(					a ,  a							):
       __a     				=  [[] for _ in range(UpperCAmelCase_							)]
       for u, v in edges:
              g[u].append(UpperCAmelCase_							)
       return g


if __name__ == "__main__":
 # Test
 SCREAMING_SNAKE_CASE__:str			=	7
 SCREAMING_SNAKE_CASE__:List[Any]			=	[0, 0, 1, 2, 3, 3, 4, 4, 6]
 SCREAMING_SNAKE_CASE__:Union[str, Any]			=	[1, 3, 2, 0, 1, 4, 5, 6, 5]
 SCREAMING_SNAKE_CASE__:Any			=	[(u, v) for u, v in zip(source, target)]
 SCREAMING_SNAKE_CASE__:List[Any]			=	create_graph(n_vertices, edges)

 assert [[5], [6], [4], [3, 2, 1, 0]] == tarjan(g)

"""simple docstring"""



from __future__ import annotations



def 					_lowerCamelCase(					a ,  a ,  a ,  a ,  a ,  ):
       __a     				=  len(a							)

       # If row is equal to the size of the board it means there are a queen in each row in
       # the current board (possible_board)
       if row == n:
              # We convert the variable possible_board that looks like this: [1, 3, 0, 2] to
              # this: ['. Q . . ', '. . . Q ', 'Q . . . ', '. . Q . ']
              boards.append([". " * i + "Q " + ". " * (n - 1 - i) for i in possible_board]							)
              return

       # We iterate each column in the row to find all possible results in each row
       for col in range(a							):
              # We apply that we learned previously. First we check that in the current board
              # (possible_board) there are not other same value because if there is it means
              # that there are a collision in vertical. Then we apply the two formulas we
              # learned before:
              #
              # 45º: y - x = b or 45: row - col = b
              # 135º: y + x = b or row + col = b.
              #
              # And we verify if the results of this two formulas not exist in their variables
              # respectively.  (diagonal_right_collisions, diagonal_left_collisions)
              #
              # If any or these are True it means there is a collision so we continue to the
              # next value in the for loop.
              if (
                  col in possible_board
                  or row - col in diagonal_right_collisions
                  or row + col in diagonal_left_collisions
              ):
                     continue

              # If it is False we call dfs function again and we update the inputs
              depth_first_search(
                  [*possible_board, col] ,  [*diagonal_right_collisions, row - col] ,  [*diagonal_left_collisions, row + col] ,  a ,  a ,  )



def 					_lowerCamelCase(					a							):
       __a     				=  []
       depth_first_search([] ,  [] ,  [] ,  a ,  a							)

       # Print all the boards
       for board in boards:
              for column in board:
                     print(a							)
              print(""							)

       print(len(a							) ,  "solutions were found."							)


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   n_queens_solution(4)
