

import heapq as hq
import math
from collections.abc import Iterator

class   _a					:




      """simple docstring"""

      def __init__(   self							:				Any						,			UpperCAmelCase							:				Dict	):
            A_						  =				str(id_	)
            A_						  =				None
            A_						  =				None
            A_						  =				[]
            A_						  =				{}  # {vertex:distance}





      def __lt__(   self							:				Dict						,			UpperCAmelCase							:				Union[str, Any]	):
            return self.key < other.key





      def __repr__(   self							:				Optional[int]	):
            return self.id





      def 		__A	(   self							:				Any						,			UpperCAmelCase							:				Optional[Any]	):
            self.neighbors.append(UpperCAmelCase	)







      def 		__A	(   self							:				int						,			UpperCAmelCase							:				Union[str, Any]						,			UpperCAmelCase							:				int	):
            A_						  =				weight




def       __snake_case						( __UpperCamelCase	: Any				,__UpperCamelCase	: str				,__UpperCamelCase	: Tuple				,__UpperCamelCase	: Dict    ):



      """simple docstring"""

      graph[a - 1].add_neighbor(graph[b - 1]    )
      graph[b - 1].add_neighbor(graph[a - 1]    )
      # add the edges:
      graph[a - 1].add_edge(graph[b - 1]				,__UpperCamelCase    )
      graph[b - 1].add_edge(graph[a - 1]				,__UpperCamelCase    )

def       __snake_case						( __UpperCamelCase	: list				,__UpperCamelCase	: Vertex    ):



      """simple docstring"""

      A_						  =				[]
      for u in graph:
            A_						  =				math.inf
            A_						  =				None
      A_						  =				0
      A_						  =				graph[:]
      while q:
            A_						  =				min(__UpperCamelCase    )
            q.remove(__UpperCamelCase    )
            for v in u.neighbors:
                  if (v in q) and (u.edges[v.id] < v.key):
                        A_						  =				u
                        A_						  =				u.edges[v.id]
      for i in range(1				,len(__UpperCamelCase    )    ):
            a.append((int(graph[i].id    ) + 1, int(graph[i].pi.id    ) + 1)    )
      return a

def       __snake_case						( __UpperCamelCase	: list				,__UpperCamelCase	: Vertex    ):



      """simple docstring"""

      for u in graph:
            A_						  =				math.inf
            A_						  =				None
      A_						  =				0

      A_						  =				list(__UpperCamelCase    )
      hq.heapify(__UpperCamelCase    )

      while h:
            A_						  =				hq.heappop(__UpperCamelCase    )
            for v in u.neighbors:
                  if (v in h) and (u.edges[v.id] < v.key):
                        A_						  =				u
                        A_						  =				u.edges[v.id]
                        hq.heapify(__UpperCamelCase    )

      for i in range(1				,len(__UpperCamelCase    )    ):
            yield (int(graph[i].id    ) + 1, int(graph[i].pi.id    ) + 1)

def       __snake_case						( ):



      """simple docstring"""



if __name__ == "__main__":
      import doctest

      doctest.testmod()




import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor

def        __a			(   __lowerCAmelCase   )     ->     tuple:
					return (data["data"], data["target"])

def        __a			(   __lowerCAmelCase      ,	__lowerCAmelCase      ,	__lowerCAmelCase   )     ->     np.ndarray:
					SCREAMING_SNAKE_CASE							:     int						=				XGBRegressor(verbosity=0      ,	random_state=42   )
					xgb.fit(__lowerCAmelCase      ,	__lowerCAmelCase   )
					# Predict target for test data
					SCREAMING_SNAKE_CASE							:     List[Any]						=				xgb.predict(__lowerCAmelCase   )
					SCREAMING_SNAKE_CASE							:     str						=				predictions.reshape(len(__lowerCAmelCase   )      ,	1   )
					return predictions

def        __a			(   )     ->     None:
					SCREAMING_SNAKE_CASE							:     Dict						=				fetch_california_housing()
					SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     Any						=				data_handling(__lowerCAmelCase   )
					SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE					,  SCREAMING_SNAKE_CASE							:     str						=				train_test_split(
					    __lowerCAmelCase      ,	__lowerCAmelCase      ,	test_size=0.25      ,	random_state=1   )
					SCREAMING_SNAKE_CASE							:     int						=				xgboost(__lowerCAmelCase      ,	__lowerCAmelCase      ,	__lowerCAmelCase   )
					# Error printing
					print(F'''Mean Absolute Error : {mean_absolute_error(__lowerCAmelCase      ,	__lowerCAmelCase   )}'''   )
					print(F'''Mean Square Error  : {mean_squared_error(__lowerCAmelCase      ,	__lowerCAmelCase   )}'''   )


if __name__ == "__main__":
			import doctest

			doctest.testmod(verbose=True)
			main()