
from __future__ import annotations

from queue import Queue

def    __snake_case       (  __magic_name__		,						__magic_name__	):







				'''simple docstring'''


				a ^= b
				b ^= a
				a ^= b
				return a, b

def    __snake_case       (  __magic_name__		,						__magic_name__	):







				'''simple docstring'''


				lowercase						    =			1
				while (1 << j) < max_node:
								for i in range(1		,						max_node + 1	):
												lowercase						    =			parent[j - 1][parent[j - 1][i]]
								j += 1
				return parent

def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__		,						__magic_name__	):







				'''simple docstring'''


				if level[u] < level[v]:
								lowercase						    =			swap(UpperCamelCase__		,						UpperCamelCase__	)
				# making depth of u same as depth of v
				for i in range(18		,						-1		,						-1	):
								if level[u] - (1 << i) >= level[v]:
												lowercase						    =			parent[i][u]
    # at the same depth if u==v that mean lca is found
				if u == v:
								return u
				# moving both nodes upwards till lca in found
				for i in range(18		,						-1		,						-1	):
								if parent[i][u] not in [0, parent[i][v]]:
												lowercase						    =			parent[i][u], parent[i][v]
    # returning longest common ancestor of u,v
				return parent[0][u]

def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__		,						__magic_name__		,						__magic_name__ = 1		,						):







				'''simple docstring'''


				lowercase						    =			0
				lowercase						    =			Queue(maxsize=UpperCamelCase__	)
				q.put(UpperCamelCase__	)
				while q.qsize() != 0:
								lowercase						    =			q.get()
								for v in graph[u]:
												if level[v] == -1:
																lowercase						    =			level[u] + 1
																q.put(UpperCamelCase__	)
																lowercase						    =			u
				return level, parent

def    __snake_case       (  ):







				'''simple docstring'''


				lowercase						    =			13
				# initializing with 0
				lowercase						    =			[[0 for _ in range(max_node + 10	)] for _ in range(20	)]
				# initializing with -1 which means every node is unvisited
				lowercase						    =			[-1 for _ in range(max_node + 10	)]
				lowercase						    =			{
				    1: [2, 3, 4],
				    2: [5],
				    3: [6, 7],
				    4: [8],
				    5: [9, 10],
				    6: [11],
				    7: [],
				    8: [12, 13],
				    9: [],
				    10: [],
				    11: [],
				    12: [],
				    13: [],
				}
				lowercase						    =			breadth_first_search(UpperCamelCase__		,						UpperCamelCase__		,						UpperCamelCase__		,						UpperCamelCase__		,						1	)
				lowercase						    =			create_sparse(UpperCamelCase__		,						UpperCamelCase__	)
				print("LCA of node 1 and 3 is: "		,						lowest_common_ancestor(1		,						3		,						UpperCamelCase__		,						UpperCamelCase__	)	)
				print("LCA of node 5 and 6 is: "		,						lowest_common_ancestor(5		,						6		,						UpperCamelCase__		,						UpperCamelCase__	)	)
				print("LCA of node 7 and 11 is: "		,						lowest_common_ancestor(7		,						11		,						UpperCamelCase__		,						UpperCamelCase__	)	)
				print("LCA of node 6 and 7 is: "		,						lowest_common_ancestor(6		,						7		,						UpperCamelCase__		,						UpperCamelCase__	)	)
				print("LCA of node 4 and 12 is: "		,						lowest_common_ancestor(4		,						12		,						UpperCamelCase__		,						UpperCamelCase__	)	)
				print("LCA of node 8 and 8 is: "		,						lowest_common_ancestor(8		,						8		,						UpperCamelCase__		,						UpperCamelCase__	)	)


if __name__ == "__main__":
						main()


import sys
from collections.abc import Mapping

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter





class      UpperCamelCase_			(			TensorFormatter[Mapping, np.ndarray, Mapping]		):







						'''simple docstring'''



						def __init__( self       :int		,						lowerCAmelCase__       :Any=None		,						**lowerCAmelCase__       :Union[str, Any]    )     ->int:
										super().__init__(features=lowerCAmelCase__    )
										lowercase						    =			np_array_kwargs





						def 					SCREAMING_SNAKE_CASE( self       :Union[str, Any]		,						lowerCAmelCase__       :str    )     ->Optional[Any]:
										if isinstance(lowerCAmelCase__		,						lowerCAmelCase__    ):
														if column and all(
														    isinstance(lowerCAmelCase__		,						np.ndarray    ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column    ):
																		return np.stack(lowerCAmelCase__    )
														else:
																		# don't use np.array(column, dtype=object)
																		# since it fails in certain cases
																		# see https://stackoverflow.com/q/51005699
																		lowercase						    =			np.empty(len(lowerCAmelCase__    )		,						dtype=lowerCAmelCase__    )
																		lowercase						    =			column
																		return out
										return column





						def 					SCREAMING_SNAKE_CASE( self       :str		,						lowerCAmelCase__       :List[str]    )     ->Union[str, Any]:
										if isinstance(lowerCAmelCase__		,						(str, bytes, type(lowerCAmelCase__    ))    ):
														return value
										elif isinstance(lowerCAmelCase__		,						(np.character, np.ndarray)    ) and np.issubdtype(value.dtype		,						np.character    ):
														return value
										elif isinstance(lowerCAmelCase__		,						np.number    ):
														return value

										lowercase						    =			{}

										if isinstance(lowerCAmelCase__		,						np.ndarray    ) and np.issubdtype(value.dtype		,						np.integer    ):
														lowercase						    =			{"dtype": np.intaa}
										elif isinstance(lowerCAmelCase__		,						np.ndarray    ) and np.issubdtype(value.dtype		,						np.floating    ):
														lowercase						    =			{"dtype": np.floataa}
										elif config.PIL_AVAILABLE and "PIL" in sys.modules:
														import PIL.Image

														if isinstance(lowerCAmelCase__		,						PIL.Image.Image    ):
																		return np.asarray(lowerCAmelCase__		,						**self.np_array_kwargs    )

										return np.asarray(lowerCAmelCase__		,						**{**default_dtype, **self.np_array_kwargs}    )





						def 					SCREAMING_SNAKE_CASE( self       :int		,						lowerCAmelCase__       :Dict    )     ->int:
										# support for torch, tf, jax etc.
										if config.TORCH_AVAILABLE and "torch" in sys.modules:
														import torch

														if isinstance(lowerCAmelCase__		,						torch.Tensor    ):
																		return self._tensorize(data_struct.detach().cpu().numpy()[()]    )
										if hasattr(lowerCAmelCase__		,						"__array__"    ) and not isinstance(lowerCAmelCase__		,						(np.ndarray, np.character, np.number)    ):
														lowercase						    =			data_struct.__array__()
										# support for nested types like struct of list of struct
										if isinstance(lowerCAmelCase__		,						np.ndarray    ):
														if data_struct.dtype == object:
																		return self._consolidate([self.recursive_tensorize(lowerCAmelCase__    ) for substruct in data_struct]    )
										if isinstance(lowerCAmelCase__		,						(list, tuple)    ):
														return self._consolidate([self.recursive_tensorize(lowerCAmelCase__    ) for substruct in data_struct]    )
										return self._tensorize(lowerCAmelCase__    )





						def 					SCREAMING_SNAKE_CASE( self       :int		,						lowerCAmelCase__       :dict    )     ->str:
										return map_nested(self._recursive_tensorize		,						lowerCAmelCase__		,						map_list=lowerCAmelCase__    )





						def 					SCREAMING_SNAKE_CASE( self       :Tuple		,						lowerCAmelCase__       :pa.Table    )     ->Mapping:
										lowercase						    =			self.numpy_arrow_extractor().extract_row(lowerCAmelCase__    )
										lowercase						    =			self.python_features_decoder.decode_row(lowerCAmelCase__    )
										return self.recursive_tensorize(lowerCAmelCase__    )





						def 					SCREAMING_SNAKE_CASE( self       :str		,						lowerCAmelCase__       :pa.Table    )     ->np.ndarray:
										lowercase						    =			self.numpy_arrow_extractor().extract_column(lowerCAmelCase__    )
										lowercase						    =			self.python_features_decoder.decode_column(lowerCAmelCase__		,						pa_table.column_names[0]    )
										lowercase						    =			self.recursive_tensorize(lowerCAmelCase__    )
										lowercase						    =			self._consolidate(lowerCAmelCase__    )
										return column





						def 					SCREAMING_SNAKE_CASE( self       :List[Any]		,						lowerCAmelCase__       :pa.Table    )     ->Mapping:
										lowercase						    =			self.numpy_arrow_extractor().extract_batch(lowerCAmelCase__    )
										lowercase						    =			self.python_features_decoder.decode_batch(lowerCAmelCase__    )
										lowercase						    =			self.recursive_tensorize(lowerCAmelCase__    )
										for column_name in batch:
														lowercase						    =			self._consolidate(batch[column_name]    )
										return batch
