init-commit

internbootcamp/bootcamp/cbearanddrawing/cbearanddrawing.py

@@ -0,0 +1,253 @@
+"""# 
+
+### 谜题描述
+Limak is a little bear who learns to draw. People usually start with houses, fences and flowers but why would bears do it? Limak lives in the forest and he decides to draw a tree.
+
+Recall that tree is a connected graph consisting of n vertices and n - 1 edges.
+
+Limak chose a tree with n vertices. He has infinite strip of paper with two parallel rows of dots. Little bear wants to assign vertices of a tree to some n distinct dots on a paper so that edges would intersect only at their endpoints — drawn tree must be planar. Below you can see one of correct drawings for the first sample test.
+
+<image>
+
+Is it possible for Limak to draw chosen tree?
+
+Input
+
+The first line contains single integer n (1 ≤ n ≤ 105).
+
+Next n - 1 lines contain description of a tree. i-th of them contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) denoting an edge between vertices ai and bi. It's guaranteed that given description forms a tree.
+
+Output
+
+Print \"Yes\" (without the quotes) if Limak can draw chosen tree. Otherwise, print \"No\" (without the quotes).
+
+Examples
+
+Input
+
+8
+1 2
+1 3
+1 6
+6 4
+6 7
+6 5
+7 8
+
+
+Output
+
+Yes
+
+
+Input
+
+13
+1 2
+1 3
+1 4
+2 5
+2 6
+2 7
+3 8
+3 9
+3 10
+4 11
+4 12
+4 13
+
+
+Output
+
+No
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+#include <bits/stdc++.h>
+using namespace std;
+const int INF = 1000001000;
+const long long INFL = 2000000000000001000;
+int solve();
+int main() {
+  srand(2317);
+  cout.precision(10);
+  cout.setf(ios::fixed);
+  int tn = 1;
+  for (int i = 0; i < tn; ++i) solve();
+}
+const int maxn = 2e5;
+vector<int> g[maxn];
+bool del[maxn];
+int bamboo[maxn];
+bool type2[maxn];
+queue<int> o;
+int solve() {
+  int n;
+  cin >> n;
+  for (int i = 0; i < int(n - 1); ++i) {
+    int u, v;
+    cin >> u >> v;
+    --u, --v;
+    g[u].push_back(v);
+    g[v].push_back(u);
+  }
+  for (int i = 0; i < int(n); ++i)
+    if (((int)(g[i]).size()) == 1) o.push(i);
+  while (!o.empty()) {
+    int u = o.front();
+    del[u] = true;
+    o.pop();
+    for (int v : g[u]) {
+      if (del[v]) continue;
+      if (((int)(g[v]).size()) == 2)
+        o.push(v);
+      else
+        ++bamboo[v];
+    }
+  }
+  bool fail = false;
+  for (int i = 0; i < int(n); ++i) {
+    if (del[i]) continue;
+    if (((int)(g[i]).size()) <= 3 && ((int)(g[i]).size()) <= bamboo[i] + 1)
+      type2[i] = true;
+  }
+  for (int i = 0; i < int(n); ++i) {
+    if (type2[i] || del[i]) continue;
+    int deg = 0;
+    for (int v : g[i])
+      if (!type2[v] && !del[v]) ++deg;
+    if (deg > 2) fail = true;
+  }
+  if (fail)
+    cout << \"No\n\";
+  else
+    cout << \"Yes\n\";
+  return 0;
+}
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+from collections import deque
+from bootcamp import Basebootcamp
+
+class Cbearanddrawingbootcamp(Basebootcamp):
+    def __init__(self, max_nodes=20, seed=None):
+        super().__init__()
+        self.max_nodes = max_nodes
+        self.seed = seed or random.randint(0, 999999)
+        random.seed(self.seed)
+    
+    def case_generator(self):
+        n = random.randint(1, self.max_nodes)
+        edges = self._generate_random_tree(n)
+        answer = self._check_tree_planar(n, edges)
+        return {
+            'n': n,
+            'edges': edges,
+            'answer': answer
+        }
+    
+    def _generate_random_tree(self, n):
+        """使用Prüfer序列生成随机树"""
+        if n == 1:
+            return []
+        # 生成Prüfer序列
+        prufer = [random.randint(1, n) for _ in range(n-2)]
+        # 生成树边
+        degree = [1] * (n + 1)  # 节点编号1-based
+        for node in prufer:
+            degree[node] += 1
+        
+        edges = []
+        for node in prufer:
+            for leaf in range(1, n+1):
+                if degree[leaf] == 1:
+                    edges.append((node, leaf))
+                    degree[node] -= 1
+                    degree[leaf] -= 1
+                    break
+        
+        # 处理最后两个节点
+        leaves = [i for i in range(1, n+1) if degree[i] == 1]
+        edges.append((leaves[0], leaves[1]))
+        return edges
+    
+    def _check_tree_planar(self, n, edges):
+        if n <= 2:
+            return "Yes"
+        
+        # 构建邻接表（0-based）
+        adj = [[] for _ in range(n)]
+        for u, v in edges:
+            adj[u-1].append(v-1)
+            adj[v-1].append(u-1)
+        
+        del_ = [False]*n
+        bamboo = [0]*n
+        q = deque()
+        
+        # 初始化队列
+        for i in range(n):
+            if len(adj[i]) == 1:
+                q.append(i)
+        
+        # BFS处理叶子节点
+        while q:
+            u = q.popleft()
+            del_[u] = True
+            for v in adj[u]:
+                if del_[v]: continue
+                original_degree = len(adj[v])
+                if original_degree == 2:
+                    q.append(v)
+                else:
+                    bamboo[v] += 1
+        
+        # 标记type2节点
+        type2 = [False]*n
+        for i in range(n):
+            if del_[i]: continue
+            original_degree = len(adj[i])
+            if original_degree <= 3 and original_degree <= bamboo[i] + 1:
+                type2[i] = True
+        
+        # 最终验证
+        fail = False
+        for i in range(n):
+            if del_[i] or type2[i]: continue
+            cnt = 0
+            for v in adj[i]:
+                if not del_[v] and not type2[v]:
+                    cnt += 1
+                    if cnt > 2:
+                        fail = True
+                        break
+            if fail: break
+        
+        return "Yes" if not fail else "No"
+
+    @staticmethod
+    def prompt_func(question_case):
+        edges = '\n'.join(f"{u} {v}" for u, v in question_case['edges'])
+        return f"""Cbearanddrawing wants to draw a tree on a two-row grid without edge crossings. Determine if this tree can be drawn planarly.
+
+Input:
+{question_case['n']}
+{edges}
+
+Output format: [answer]Yes[/answer] or [answer]No[/answer]"""
+
+    @staticmethod
+    def extract_output(output):
+        import re
+        matches = re.findall(r'\[answer\](Yes|No)\[/answer\]', output, re.IGNORECASE)
+        return matches[-1].upper() if matches else None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        return (solution or "").lower() == identity['answer'].lower()