init-commit

internbootcamp/bootcamp/ccutemall/ccutemall.py

@@ -0,0 +1,247 @@
+"""# 
+
+### 谜题描述
+You're given a tree with n vertices.
+
+Your task is to determine the maximum possible number of edges that can be removed in such a way that all the remaining connected components will have even size.
+
+Input
+
+The first line contains an integer n (1 ≤ n ≤ 10^5) denoting the size of the tree. 
+
+The next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n) each, describing the vertices connected by the i-th edge.
+
+It's guaranteed that the given edges form a tree.
+
+Output
+
+Output a single integer k — the maximum number of edges that can be removed to leave all connected components with even size, or -1 if it is impossible to remove edges in order to satisfy this property.
+
+Examples
+
+Input
+
+4
+2 4
+4 1
+3 1
+
+
+Output
+
+1
+
+Input
+
+3
+1 2
+1 3
+
+
+Output
+
+-1
+
+Input
+
+10
+7 1
+8 4
+8 10
+4 7
+6 5
+9 3
+3 5
+2 10
+2 5
+
+
+Output
+
+4
+
+Input
+
+2
+1 2
+
+
+Output
+
+0
+
+Note
+
+In the first example you can remove the edge between vertices 1 and 4. The graph after that will have two connected components with two vertices in each.
+
+In the second example you can't remove edges in such a way that all components have even number of vertices, so the answer is -1.
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+def main():
+  n = input()
+  if n % 2 != 0:
+    print(-1)
+    return
+  links = [[1, set()] for i in range(1, n+1)]
+  W = 0
+  L = 1
+  i = 0
+  while i < n-1:
+    i += 1
+    [a, b] = [int(x) for x in raw_input().split()]
+    links[a-1][L].add(b-1)
+    links[b-1][L].add(a-1)
+  count = 0
+  sear = 0
+  cur = 0
+  while sear < n:
+    li = cur
+    l = links[li]
+    if len(l[L]) != 1:
+      if sear == cur:
+        sear += 1
+      cur = sear
+      continue
+    mi = l[L].pop()
+    m = links[mi]
+    if l[W] % 2 == 0:
+      count += 1
+    else:
+      m[W] += 1
+    m[L].remove(li)
+    if mi < sear:
+      cur = mi
+    else:
+      sear += 1
+      cur = sear
+  print(count)
+main()
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+import re
+from bootcamp import Basebootcamp
+
+class Ccutemallbootcamp(Basebootcamp):
+    def __init__(self, n_min=2, n_max=20, **kwargs):
+        self.n_min = max(n_min, 2)
+        self.n_max = n_max
+
+    def generate_tree(self, n):
+        """使用改进的Prüfer序列生成更平衡的树结构"""
+        if n == 1:
+            return []
+        if n == 2:
+            return [(1, 2)]
+        
+        # 生成更平衡的Prüfer序列
+        prufer = []
+        for _ in range(n-2):
+            # 偏好选择中间节点
+            prufer.append(random.randint(max(1, n//4), min(n, 3*n//4)))
+        
+        degree = [1]*(n+1)
+        for node in prufer:
+            degree[node] += 1
+
+        edges = []
+        for node in prufer:
+            for v in range(1, n+1):
+                if degree[v] == 1:
+                    edges.append((node, v))
+                    degree[node] -= 1
+                    degree[v] -= 1
+                    break
+
+        # 处理剩余节点时保持随机性
+        remaining = [v for v in range(1, n+1) if degree[v] == 1]
+        edges.append((remaining.pop(), remaining.pop()))
+        
+        # 随机打乱边并确保节点顺序
+        random.shuffle(edges)
+        return [(u, v) if u < v else (v, u) for u, v in edges]
+
+    def _calculate_solution(self, n, edges):
+        """修正的DFS解法"""
+        if n % 2 != 0:
+            return -1
+        
+        # 构建邻接表
+        adj = [[] for _ in range(n+1)]
+        for u, v in edges:
+            adj[u].append(v)
+            adj[v].append(u)
+        
+        self.count = 0
+        
+        def dfs(node, parent):
+            size = 1
+            for neighbor in adj[node]:
+                if neighbor == parent:
+                    continue
+                child_size = dfs(neighbor, node)
+                size += child_size
+                if child_size % 2 == 0:
+                    self.count += 1
+            return size
+        
+        total_size = dfs(1, -1)
+        # 验证总大小
+        return self.count if total_size % 2 == 0 else -1
+
+    def case_generator(self):
+        """优化的案例生成逻辑"""
+        while True:
+            n = random.randint(self.n_min, self.n_max)
+            edges = self.generate_tree(n)
+            
+            try:
+                correct_k = self._calculate_solution(n, edges)
+            except:
+                continue  # 处理可能的递归深度问题
+            
+            # 根据奇偶性验证解的有效性
+            if (n % 2 == 1 and correct_k == -1) or (n % 2 == 0 and correct_k >= 0):
+                return {'n': n, 'edges': edges, 'correct_k': correct_k}
+
+    @staticmethod
+    def prompt_func(question_case):
+        n = question_case['n']
+        edges = question_case['edges']
+        edge_list = '\n'.join(f"{u} {v}" for u, v in edges)
+        return f"""Given a tree with {n} vertices represented by undirected edges. Find the maximum number of edges that can be removed such that all resulting connected components contain an even number of vertices. If impossible, output -1.
+
+Input Format:
+n
+u1 v1
+...
+u(n-1) v(n-1)
+
+Current Tree Structure:
+{n}
+{edge_list}
+
+Present your answer as a single integer within [answer] tags. Example: [answer]2[/answer]"""
+
+    @staticmethod
+    def extract_output(output):
+        matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
+        if not matches:
+            return None
+        try:
+            return int(matches[-1].strip())
+        except (ValueError, TypeError):
+            return None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        try:
+            return int(solution) == identity['correct_k']
+        except:
+            return False