answer:import math def generate_array_with_perfect_square_sum(n): Generate n distinct integers such that their sum is a perfect square. All integers are between 1 and 10^5. arr = list(range(1, n + 1)) arr_sum = sum(arr) # Check if the sum is already a perfect square if math.isqrt(arr_sum) ** 2 == arr_sum: return arr # Find the smallest number to add that results in a perfect square sum. k = 1 while True: if math.isqrt(arr_sum + k) ** 2 == arr_sum + k: arr.append(k) break k += 1 return arr def solve(test_cases): results = [] for n in test_cases: results.append(generate_array_with_perfect_square_sum(n)) return results

answer:def calculate_percentage_change(distances): Given a list of distances, calculate the percentage increase or decrease for each subsequent day compared to the previous day. distances: List[int] - list of distances walked over the days Returns: List[str] - list of percentage changes rounded to 2 decimal points as strings changes = [] for i in range(1, len(distances)): change = ((distances[i] - distances[i-1]) / distances[i-1]) * 100 changes.append(f"{change:.2f}") return changes def process_test_cases(test_cases): Processes multiple test cases and returns the formatted results. test_cases: List[Tuple[int, List[int]]] - list of test cases Returns: List[str] - formatted results for each test case results = [] for idx, (N, distances) in enumerate(test_cases): changes = calculate_percentage_change(distances) result = f"Case #{idx + 1}: " + " ".join(changes) results.append(result) return results

answer:import heapq import sys def dijkstra(n, graph, start): Dijkstra's algorithm to find the shortest path from start to all other vertices in a weighted graph. :param n: Number of warehouses (vertices) :param graph: Adjacency list representation of the graph :param start: Starting vertex for Dijkstra :return: List of shortest distances from start to each vertex (1-indexed) dist = [sys.maxsize] * (n + 1) dist[start] = 0 pq = [(0, start)] # (distance, vertex) while pq: current_dist, u = heapq.heappop(pq) if current_dist > dist[u]: continue for v, weight in graph[u]: if current_dist + weight < dist[v]: dist[v] = current_dist + weight heapq.heappush(pq, (dist[v], v)) return dist def fastest_delivery(n, m, k, roads, queries): Function to determine the fastest delivery route from s to d for each query. :param n: Number of warehouses :param m: Number of roads :param k: Number of queries :param roads: List of tuples representing the roads (u, v, t) :param queries: List of tuples representing the queries (s, d) :return: List containing the minimum travel time for each query or -1 if no path exists # Build the graph as an adjacency list graph = [[] for _ in range(n + 1)] for u, v, t in roads: graph[u].append((v, t)) results = [] for s, d in queries: dist = dijkstra(n, graph, s) if dist[d] == sys.maxsize: results.append(-1) else: results.append(dist[d]) return results

answer:def is_subsequence(A, B): Determines if B is a subsequence of A. Parameters: A (list): The list in which we have to check the subsequence. B (list): The potential subsequence list. Returns: bool: True if B is a subsequence of A, False otherwise. iter_A = iter(A) return all(b in iter_A for b in B) def check_subsequences(test_cases): Checks if B is a subsequence of A for a list of test cases. Parameters: test_cases (list): a list of tuples where each tuple consists of (A, B) Returns: list: a list of 'YES' or 'NO' for each test case. results = [] for A, B in test_cases: if is_subsequence(A, B): results.append("YES") else: results.append("NO") return results