init-commit

internbootcamp/bootcamp/epointsonplane/epointsonplane.py

@@ -0,0 +1,161 @@
+"""# 
+
+### 谜题描述
+On a plane are n points (xi, yi) with integer coordinates between 0 and 106. The distance between the two points with numbers a and b is said to be the following value: <image> (the distance calculated by such formula is called Manhattan distance).
+
+We call a hamiltonian path to be some permutation pi of numbers from 1 to n. We say that the length of this path is value <image>.
+
+Find some hamiltonian path with a length of no more than 25 × 108. Note that you do not have to minimize the path length.
+
+Input
+
+The first line contains integer n (1 ≤ n ≤ 106).
+
+The i + 1-th line contains the coordinates of the i-th point: xi and yi (0 ≤ xi, yi ≤ 106).
+
+It is guaranteed that no two points coincide.
+
+Output
+
+Print the permutation of numbers pi from 1 to n — the sought Hamiltonian path. The permutation must meet the inequality <image>.
+
+If there are multiple possible answers, print any of them.
+
+It is guaranteed that the answer exists.
+
+Examples
+
+Input
+
+5
+0 7
+8 10
+3 4
+5 0
+9 12
+
+
+Output
+
+4 3 1 2 5 
+
+Note
+
+In the sample test the total distance is:
+
+<image>
+
+(|5 - 3| + |0 - 4|) + (|3 - 0| + |4 - 7|) + (|0 - 8| + |7 - 10|) + (|8 - 9| + |10 - 12|) = 2 + 4 + 3 + 3 + 8 + 3 + 1 + 2 = 26
+
+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 long long MAXN = 1e6 + 1, SQ = 1200;
+int n;
+int x[MAXN], y[MAXN], a[MAXN];
+bool cmp(int i, int j) {
+  short int tmp = x[i] / SQ, tmpp = x[j] / SQ;
+  if (tmp ^ tmpp)
+    return x[i] < x[j];
+  else {
+    if (tmp & 1)
+      return y[i] > y[j];
+    else
+      return y[i] < y[j];
+  }
+}
+int main() {
+  ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
+  cin >> n;
+  for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
+  for (int i = 0; i < n; i++) a[i] = i;
+  sort(a, a + n, cmp);
+  for (int i = 0; i < n; i++) cout << a[i] + 1 << ' ';
+  return 0;
+}
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+import re
+from bootcamp import Basebootcamp
+
+class Epointsonplanebootcamp(Basebootcamp):
+    def __init__(self, n=5, SQ=1200):
+        self.n = n
+        self.SQ = SQ
+    
+    def case_generator(self):
+        n = self.n
+        SQ = self.SQ
+        points_set = set()
+        while len(points_set) < n:
+            x = random.randint(0, 10**6)
+            y = random.randint(0, 10**6)
+            points_set.add((x, y))
+        points = [list(p) for p in points_set]
+        return {
+            'n': n,
+            'points': points,
+            'SQ': SQ
+        }
+    
+    @staticmethod
+    def prompt_func(question_case):
+        input_lines = [str(question_case['n'])]
+        for point in question_case['points']:
+            input_lines.append(f"{point[0]} {point[1]}")
+        input_example = '\n'.join(input_lines)
+        prompt = f"""你是一个算法竞赛专家，需要解决一个哈密顿路径问题。题目要求找到一条路径，总曼哈顿距离不超过25×10^8。
+
+输入格式：
+- 首行为点数n（1 ≤ n ≤ 1e6)
+- 接下来n行每行两个整数，表示点的x和y坐标
+
+输出格式：
+- 一个1到n的排列，用空格分隔
+
+当前问题输入：
+{input_example}
+
+请将答案置于[answer]和[/answer]之间。"""
+        return prompt
+    
+    @staticmethod
+    def extract_output(output):
+        matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
+        if not matches:
+            return None
+        last_answer = matches[-1].strip()
+        parts = last_answer.split()
+        try:
+            solution = list(map(int, parts))
+            return solution
+        except ValueError:
+            return None
+    
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        n = identity['n']
+        points = identity['points']
+        
+        # 验证排列有效性
+        if len(solution) != n or sorted(solution) != list(range(1, n+1)):
+            return False
+        
+        # 实际计算总距离
+        total = 0
+        for i in range(n-1):
+            idx1 = solution[i] - 1
+            idx2 = solution[i+1] - 1
+            x1, y1 = points[idx1]
+            x2, y2 = points[idx2]
+            total += abs(x1 - x2) + abs(y1 - y2)
+            if total > 25e8:
+                return False
+        return total <= 25e8