from typing import List, Tuple

def getMinMaxLatency(g_nodes: int, g_from: List[int], g_to: List[int], g_weight: List[int], k: int) -> int:
    """
    This function divides a network of data centers into optimal local regions by removing some of the connections 
    such that the maximum latencies of all the regions are minimized. It returns the minimum possible value of the 
    maximum max-latency of the networks formed.
    
    Parameters:
    g_nodes (int): The number of data centers
    g_from (List[int]): One end of the connections
    g_to (List[int]): Another end of the connections
    g_weight (List[int]): The latency of the connections
    k (int): The maximum number of networks after removing some connections
    
    Returns:
    int: The minimum possible value of the max-latency of the networks formed
    
    Raises:
    ValueError: If the number of data centers is less than 1 or greater than 103
                If the number of edges is less than 1 or greater than 1.5x10^5
                If the latency of any connection is less than 1 or greater than 10^9
                If the maximum number of networks is less than 1 or greater than the number of data centers
    """
    try:
        # Check if the input constraints are met
        if g_nodes < 1 or g_nodes > 103:
            raise ValueError("The number of data centers must be between 1 and 103")
        if len(g_from) != len(g_to) or len(g_from) != len(g_weight):
            raise ValueError("The length of g_from, g_to, and g_weight must be the same")
        if len(g_from) < 1 or len(g_from) > 1.5*(10**5):
            raise ValueError("The number of edges must be between 1 and 1.5x10^5")
        if any(w < 1 or w > 10**9 for w in g_weight):
            raise ValueError("The latency of any connection must be between 1 and 10^9")
        if k < 1 or k > g_nodes:
            raise ValueError("The maximum number of networks must be between 1 and the number of data centers")

        # Create an adjacency list to represent the graph
        graph = {i: [] for i in range(1, g_nodes+1)}
        for i in range(len(g_from)):
            graph[g_from[i]].append((g_to[i], g_weight[i]))
            graph[g_to[i]].append((g_from[i], g_weight[i]))
        
        # Define a function to check if the graph is connected
        def is_connected(graph):
            visited = set()
            stack = [1]
            while stack:
                node = stack.pop()
                if node not in visited:
                    visited.add(node)
                    stack.extend([n for n, w in graph[node]])
            return len(visited) == g_nodes
        
        # Check if the graph is initially connected
        if not is_connected(graph):
            raise ValueError("The graph is not initially connected")
        
        # Define a function to check if the graph is k-connected
        def is_k_connected(graph, k):
            visited = set()
            stack = [1]
            while stack:
                node = stack.pop()
                if node not in visited:
                    visited.add(node)
                    stack.extend([n for n, w in graph[node]])
                    if len(visited) > k:
                        return False
            return len(visited) <= k
        
        # Define a function to check if the graph is k-connected with a maximum latency of max_latency
        def is_k_connected_with_max_latency(graph, k, max_latency):
            visited = set()
            stack = [1]
            while stack:
                node = stack.pop()
                if node not in visited:
                    visited.add(node)
                    stack.extend([n for n, w in graph[node] if w <= max_latency])
                    if len(visited) > k:
                        return False
            return len(visited) <= k
        
        # Define a function to perform binary search for the minimum possible value of the max-latency
        def binary_search_min_max_latency(graph, k):
            left = 1
            right = max(g_weight)
            while left <= right:
                mid = (left + right) // 2
                if is_k_connected_with_max_latency(graph, k, mid):
                    right = mid - 1
                else:
                    left = mid + 1
            return left
        
        # Perform binary search for the minimum possible value of the max-latency
        return binary_search_min_max_latency(graph, k)
    
    except ValueError as e:
        # Log the error
        print(f"Error: {e}")
        return 0
        
        
g_nodes = 2
g_from = [1]
g_to = [2]
g_weight = [3]
k = 1
print(getMinMaxLatency(g_nodes, g_from, g_to, g_weight, k))