"""# ### 谜题描述 A group of n cities is connected by a network of roads. There is an undirected road between every pair of cities, so there are roads in total. It takes exactly y seconds to traverse any single road. A spanning tree is a set of roads containing exactly n - 1 roads such that it's possible to travel between any two cities using only these roads. Some spanning tree of the initial network was chosen. For every road in this tree the time one needs to traverse this road was changed from y to x seconds. Note that it's not guaranteed that x is smaller than y. You would like to travel through all the cities using the shortest path possible. Given n, x, y and a description of the spanning tree that was chosen, find the cost of the shortest path that starts in any city, ends in any city and visits all cities exactly once. Input The first line of the input contains three integers n, x and y (2 ≤ n ≤ 200 000, 1 ≤ x, y ≤ 109). Each of the next n - 1 lines contains a description of a road in the spanning tree. The i-th of these lines contains two integers ui and vi (1 ≤ ui, vi ≤ n) — indices of the cities connected by the i-th road. It is guaranteed that these roads form a spanning tree. Output Print a single integer — the minimum number of seconds one needs to spend in order to visit all the cities exactly once. Examples Input 5 2 3 1 2 1 3 3 4 5 3 Output 9 Input 5 3 2 1 2 1 3 3 4 5 3 Output 8 Note In the first sample, roads of the spanning tree have cost 2, while other roads have cost 3. One example of an optimal path is . In the second sample, we have the same spanning tree, but roads in the spanning tree cost 3, while other roads cost 2. One example of an optimal path is . Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution. ```python def rlist(t): return map(t, raw_input().split()) def read_int_list(): return rlist(int) def write_list(lst, divider=\" \"): print divider.join(map(str, lst)) def read_graph(vertices, edges): graph = [[] for _ in xrange(vertices)] for _ in xrange(edges): v, u = read_int_list() graph[v-1].append(u-1) graph[u-1].append(v-1) return graph def dfs(graph, start=0): track = [[start, -1]] stack = [start] visited_neighbours = [0 for _ in xrange(len(graph))] # -1 for closed while stack: curr = stack[-1] if visited_neighbours[curr] == len(graph[curr]): visited_neighbours[curr] = -1 stack.pop() else: neighbour = graph[curr][visited_neighbours[curr]] visited_neighbours[curr] += 1 if not visited_neighbours[neighbour]: # current neighbour unvisited stack.append(neighbour) track.append([neighbour, curr]) return track n, x, y = read_int_list() graph = read_graph(n, n-1) maxans = [[0, 0] for i in xrange(n)] if x >= y: flag = False for i in graph: if len(i) == (n-1): flag = True break if flag: print x + y * (n-2) else: print y * (n-1) else: track = dfs(graph) track.reverse() for curr, prev in track: summ = 0 goodcnt = 0 for v in graph[curr]: if v != prev: summ += maxans[v][0] if maxans[v][1]: goodcnt += 1 maxans[curr][0] = summ + min(2, goodcnt) maxans[curr][1] = 0 if goodcnt >= 2 else 1 ans = maxans[0][0] print x * ans + y * (n-1-ans) ``` 请完成上述谜题的训练场环境类实现，包括所有必要的方法。 """ from bootcamp import Basebootcamp import random import re from bootcamp import Basebootcamp class Dhamiltonianspanningtreebootcamp(Basebootcamp): def __init__(self, min_n=2, max_n=10, **params): self.min_n = min_n self.max_n = max_n self.params = params def case_generator(self): n = random.randint(self.min_n, self.max_n) edges = [] # Generate a random spanning tree using parent assignment method for i in range(2, n + 1): parent = random.randint(1, i - 1) edges.append([i, parent]) x = random.randint(1, 10) y = random.randint(1, 10) # Build adjacency list (0-based) graph = [[] for _ in range(n)] for u, v in edges: u0 = u - 1 v0 = v - 1 graph[u0].append(v0) graph[v0].append(u0) # Calculate correct answer based on reference solution logic if x >= y: has_center = any(len(adj) == n - 1 for adj in graph) correct = x + y * (n - 2) if has_center else y * (n - 1) else: track = self.dfs(graph) track.reverse() maxans = [[0, 0] for _ in range(n)] for curr, prev in track: summ = 0 goodcnt = 0 for neighbor in graph[curr]: if neighbor != prev: summ += maxans[neighbor][0] if maxans[neighbor][1]: goodcnt += 1 maxans[curr][0] = summ + min(2, goodcnt) maxans[curr][1] = 0 if goodcnt >= 2 else 1 ans = maxans[0][0] correct = x * ans + y * (n - 1 - ans) return { 'n': n, 'x': x, 'y': y, 'edges': edges, 'correct_answer': correct } @staticmethod def dfs(graph, start=0): track = [[start, -1]] stack = [start] visited = [0] * len(graph) # 0: unprocessed, -1: processed while stack: curr = stack[-1] if visited[curr] >= len(graph[curr]): visited[curr] = -1 stack.pop() else: neighbor_idx = visited[curr] neighbor = graph[curr][neighbor_idx] visited[curr] += 1 if visited[neighbor] == 0: stack.append(neighbor) track.append([neighbor, curr]) return track @staticmethod def prompt_func(question_case) -> str: n = question_case['n'] x = question_case['x'] y = question_case['y'] edges = question_case['edges'] edge_list = '\n'.join([f"{u} {v}" for u, v in edges]) return f"""你是一个专业的算法竞赛选手，需要解决以下问题： **题目背景** {n}个城市通过道路网络相连。每对城市之间都有一条双向道路，总共有{n*(n-1)//2}条路。初始所有道路通行时间为{y}秒。之后选定了其中一棵生成树（即连接所有城市的{n-1}条无环路），树中的道路通行时间被改为{x}秒。 **任务** 找到一条访问所有城市恰好一次的最短路径，并计算其总时间。 **输入格式** 第一行：三个整数n, x, y（2 ≤ n ≤ 2e5） 随后{n-1}行：每行两个整数表示生成树中的边 **输入实例** {n} {x} {y} {edge_list} **输出格式** 一个整数表示最短时间，确保答案在[answer]标签内，如：[answer]123[/answer]。 请给出答案：""" @staticmethod def extract_output(output): matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL) if not matches: return None last_match = matches[-1].strip() try: return int(last_match) except: nums = re.findall(r'-?\d+', last_match) return int(nums[-1]) if nums else None @classmethod def _verify_correction(cls, solution, identity): return solution == identity['correct_answer']