3. Cluster Queries

In a Salesforce global infrastructure, there are customer support clusters numbered from 1 to clusters, distributed across multiple regions. These clusters are interconnected by n communication links, represented by the array connections, such that if two clusters are connected directly or indirectly, they belong to the same support network.

Each cluster has a case resolut ion system to handle customer cases. If a cluster's resolution system goes offline, it forwards the cases to the active cluster in the same support network with the lowest ID, which then resolves the cases. If no active clusters remain in the network, the case is logged as unresolved.

You need to process q queries of two types:

1. A case-assignment query: "1 cluster_id", where a case is assigned to the specified cluster.
2. A system-failure query: "2 cluster_id", where the resolution system of the specified cluster goes offline.

For each case-assignment query, output the ID of the cluster that resolves the case. Specifically:
- When a case-assignment query is made to cluster sender_cluster_id, find the active cluster in the same support network as sender_cluster_id with the lowest ID and output its ID.
- If no active clusters remain in the network, output -1.

Example:
Suppose:
clusters = 3
n = 2
connections = [[1, 2], [2, 3]]
q = 5
queries = [[2, 2], [1, 2], [2, 1], [2, 3], [1, 1]]

Function Description:
Complete the function getAssignedCluster in the editor below.

getAssignedCluster has the following parameters:
- int clusters: number of clusters
- int connections[n][2]: the connections between clusters
- int queries[q][2]: the queries

Returns:
- int: the ID of the cluster that resolves the case, or -1 if no active cluster remains in the network.

Constraints:
- 1 ≤ clusters ≤ 10^5
- 0 ≤ n ≤ 10^5
- 1 ≤ q ≤ 2 × 10^5
- 1 ≤ connections[i][0], connections[i][1] ≤ clusters
- 1 ≤ queries[i][0] ≤ 2
- 1 ≤ queries[i][1] ≤ clusters
- There is at least 1 query of type 1.

Input Format For Custom Testing:
The first line contains an integer, clusters.
The next line contains an integer, n, the number of interconnections.
The next line contains an integer, 2.

Each line i of the subsequent n lines (where 0 ≤ i < n) contains two integers, connections[i][0] and connections[i][1].

The next line contains an integer, q, the number of queries.
The next line contains an integer, 2.

Each line i of the subsequent q lines (where 0 ≤ i < q) contains two integers, queries[i][0] and queries[i][1]. Show More

2. Salesforce Latency Optimization

Given a Salesforce infrastructure with API nodes, cloud regions, and API edges (bidirectional API connections between them), the i-th connection links regions api_from[i] and api_to[i] with a latency of api_weight[i]. The max-latency of a region is the maximum latency of any API within that region.

Split this infrastructure into at most k independent region s by disabling some API connections such that the maximum of the max-latency of all regions formed is minimized. Given api_nodes, api_from, and api_to, determine the minimum possible value of the maximum max-latency of the regions formed.

Example:
Suppose:
api_nodes = 3
m = 3
k = 2
api_from = [1, 2, 3]
api_to = [2, 3, 1]
api_weight = [4, 5, 3]

Function Description:
Complete the function optimizeAPIRegions in the editor below.

optimizeAPIRegions has the following parameter(s):
- api_nodes: the number of cloud regions
- api_from[api_edges]: one endpoint of the API connections
- api_to[api_edges]: the other endpoint of the API connections
- api_weight[api_edges]: the latency of the API connections
- k: the maximum number of regions after disabling some APIs

Returns:
- int: the minimum possible value of the maximum of max-latency of the networks formed

Constraints:
- 1 ≤ api_nodes ≤ 10^5
- 0 ≤ api_edges ≤ 1.5 × 10^5
- 1 ≤ api_from[i], api_to[i] ≤ api_nodes
- 1 ≤ api_weight[i] ≤ 10^9
- 1 ≤ k ≤ n
- It is guaranteed that the graph is initially connected.

Input Format For Custom Testing:
Sample Case 0:

Sample Input For Custom Testing:
STDIN:
api_nodes = 2, api_edges = 1
api_from = [1]
api_to = [2]
api_weight = [3]
k = 1

Sample Output:
3

Explanation:
In this case, the graph has 2 nodes connected by 1 API edge with latency 3. Since we are allowed to create only 1 region (k=1), the minimum possible value of the maximum latency of the network is 3. Show More

1. Salesforce Cloud server requests

In a Salesforce multi-cloud architecture, there is a circular network of m cloud servers, numbered from 1 to m, where servers 1 and m are adjacent. These servers handle various customer requests, and the latency between switching from one server to the next or the previous is given by an array, transitionTime[i], representing the time required to transition f rom the ith server to its adjacent servers.

A sequence of requested servers (represented as an array of length n, requestedServers) must be visited in the given order to handle customer workloads. The task is to determine the minimum time required to process all the requests, starting from server 1.

Example:
m = 3
n = 4
transitionTime = [3, 2, 1]
requestedServers = [1, 3, 3, 2]

- The pointer is initially at server 1, and the first server to be visited is number 1, hence it takes 0 seconds to visit it.
- To move from server 1 to 3, the path followed could be 1 -> 2 -> 3, which takes 3 + 2 = 5 seconds, or the path could be 1 -> 3, which takes 3 seconds. Choosing the shorter path, server 3 is visited in 3 seconds.
- The pointer is already at server 3, so the third server takes no time to visit.
- To move from server 3 to 2, either the path could be 3 -> 2, which takes 1 second, or the path could be 3 -> 1 -> 2, which takes 1 + 3 = 4 seconds. Choosing the shorter path, the fourth required server is visited in 1 second after visiting the third server.

Hence, the minimum possible time to visit all the required servers is 4 seconds.

Function Description:
Complete the function minRequestTime in the editor below.

minRequestTime takes the following parameter(s):
- int requestedServers[n]: the sequence of servers to be visited
- int transitionTime[m]: the time taken to switch connections from each server and connect to its adjacent server

Returns:
- long: the minimum total time required to visit all the requested servers, considering the transition time of servers

Constraints:
- 1 ≤ requestedServers(i) ≤ m
- 1 ≤ m ≤ 1000
- 1 ≤ transitionTime(i) ≤ 10^6 Show More