init-commit

internbootcamp/bootcamp/ccycle/ccycle.py

@@ -0,0 +1,214 @@
+"""# 
+
+### 谜题描述
+A tournament is a directed graph without self-loops in which every pair of vertexes is connected by exactly one directed edge. That is, for any two vertexes u and v (u ≠ v) exists either an edge going from u to v, or an edge from v to u.
+
+You are given a tournament consisting of n vertexes. Your task is to find there a cycle of length three.
+
+Input
+
+The first line contains an integer n (1 ≤ n ≤ 5000). Next n lines contain the adjacency matrix A of the graph (without spaces). Ai, j = 1 if the graph has an edge going from vertex i to vertex j, otherwise Ai, j = 0. Ai, j stands for the j-th character in the i-th line.
+
+It is guaranteed that the given graph is a tournament, that is, Ai, i = 0, Ai, j ≠ Aj, i (1 ≤ i, j ≤ n, i ≠ j).
+
+Output
+
+Print three distinct vertexes of the graph a1, a2, a3 (1 ≤ ai ≤ n), such that Aa1, a2 = Aa2, a3 = Aa3, a1 = 1, or \"-1\", if a cycle whose length equals three does not exist. 
+
+If there are several solutions, print any of them.
+
+Examples
+
+Input
+
+5
+00100
+10000
+01001
+11101
+11000
+
+
+Output
+
+1 3 2 
+
+Input
+
+5
+01111
+00000
+01000
+01100
+01110
+
+
+Output
+
+-1
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+from sys import stdin, stdout
+input = stdin.readline
+import gc
+gc.disable()
+
+def f():
+    p, q, n = [0], [0], int(input())
+    input()
+    for i in range(1, n):
+        t = input()[: i]
+        if '0' in t:
+            if '1' in t:
+                for l, j in enumerate(p): 
+                    if t[j] == '1': 
+                        for r, j in enumerate(q):
+                            if t[j] == '0':                             
+                                if l + r == i: break
+                                return str(p[l] + 1) + ' ' + str(q[r] + 1) + ' ' + str(i + 1)
+                        break
+                p.insert(l, i)
+                q.insert(i - l, i)
+            else: 
+                p.append(i)
+                q = [i] + q
+        else: 
+            p = [i] + p
+            q.append(i)
+    return -1
+print(f())
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import re
+import random
+
+from bootcamp import Basebootcamp
+
+class Ccyclebootcamp(Basebootcamp):
+    def __init__(self, n=5, has_cycle=True):
+        self.n = n
+        self.has_cycle = has_cycle
+
+    def case_generator(self):
+        n = self.n
+        has_cycle = self.has_cycle
+
+        # 处理n < 3的情况，无法形成环
+        if n < 3 and has_cycle:
+            print("Warning: For n < 3, a cycle of length 3 is impossible. Setting has_cycle to False.")
+            has_cycle = False
+
+        adj_matrix = []
+        if has_cycle:
+            # 初始化一个n x n的矩阵，初始为0
+            matrix = [[0 for _ in range(n)] for _ in range(n)]
+            # 随机选择三个顶点形成环
+            if n >= 3:
+                # 随机选择三个不同的顶点
+                vertices = random.sample(range(n), 3)
+                a, b, c = vertices
+                # 构造环：a→b, b→c, c→a
+                matrix[a][b] = 1
+                matrix[b][c] = 1
+                matrix[c][a] = 1
+                # 处理其他顶点与环顶点之间的关系
+                for i in range(n):
+                    if i not in vertices:
+                        # 选择i与环顶点的连接方式，这里假设i胜过环中的两个顶点，输给另一个
+                        # 这只是一个示例，具体可根据需要调整
+                        for j in vertices:
+                            if j == a:
+                                matrix[i][j] = 1  # i胜过a
+                            elif j == b:
+                                matrix[i][j] = 1  # i胜过b
+                            else:
+                                matrix[j][i] = 1  # c胜过i
+                        # 处理i与其他非环顶点
+                        for j in range(i + 1, n):
+                            if j not in vertices:
+                                matrix[i][j] = 1  # i胜过j
+                # 处理非环顶点之间的关系
+                for i in range(n):
+                    for j in range(i + 1, n):
+                        if i not in vertices and j not in vertices:
+                            matrix[i][j] = 1  # i胜过j
+            else:
+                # 当n <3时，无法形成环，设置为无环
+                has_cycle = False
+                matrix = [[0 for _ in range(n)] for _ in range(n)]
+                for i in range(n):
+                    for j in range(i + 1, n):
+                        matrix[i][j] = 1
+        else:
+            # 传递锦标赛，i < j则i→j
+            matrix = [[0 for _ in range(n)] for _ in range(n)]
+            for i in range(n):
+                for j in range(i + 1, n):
+                    matrix[i][j] = 1
+
+        # 将矩阵转换为字符串列表
+        adj_str = [''.join(map(str, row)) for row in matrix]
+        case = {
+            'n': n,
+            'adj_matrix': adj_str,
+            'has_cycle': has_cycle,
+            'cycle_vertices': vertices if has_cycle and n >=3 else None
+        }
+        return case
+
+    @staticmethod
+    def prompt_func(question_case):
+        n = question_case['n']
+        adj_matrix = question_case['adj_matrix']
+        prompt = "你正在分析一个包含{}个顶点的锦标赛有向图。锦标赛的性质是，对于任意两个不同的顶点u和v，恰好存在一条有向边，要么u→v，要么v→u。你的任务是找出三个顶点a1, a2, a3，使得a1→a2，a2→a3，a3→a1。如果不存在这样的环，输出-1。请将你的答案放在[answer]和[/answer]标签之间。".format(n)
+        prompt += "\n\n顶点的邻接矩阵如下：\n"
+        for i in range(n):
+            prompt += "顶点 {} 的邻接字符串：{}\n".format(i + 1, adj_matrix[i])
+        prompt += "\n例如，输出可能是：\n[answer]1 3 2[/answer]\n或者\n[answer]-1[/answer]"
+        return prompt
+
+    @staticmethod
+    def extract_output(output):
+        pattern = r'\[answer\](.*?)\[/answer\]'
+        matches = re.findall(pattern, output, re.DOTALL)
+        if not matches:
+            return None
+        answer = matches[-1].strip()
+        if answer == '-1':
+            return -1
+        else:
+            parts = answer.split()
+            if len(parts) != 3:
+                return None
+            try:
+                a1, a2, a3 = map(int, parts)
+                return (a1, a2, a3)
+            except:
+                return None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        if solution == -1:
+            return not identity['has_cycle']
+        else:
+            a1, a2, a3 = solution
+            a1 -= 1  # 转换为0-based索引
+            a2 -= 1
+            a3 -= 1
+            adj_matrix = identity['adj_matrix']
+            # 检查a1→a2
+            if a1 < 0 or a1 >= len(adj_matrix) or a2 < 0 or a2 >= len(adj_matrix[a1]) or adj_matrix[a1][a2] != '1':
+                return False
+            # 检查a2→a3
+            if a2 < 0 or a2 >= len(adj_matrix) or a3 < 0 or a3 >= len(adj_matrix[a2]) or adj_matrix[a2][a3] != '1':
+                return False
+            # 检查a3→a1
+            if a3 < 0 or a3 >= len(adj_matrix) or a1 < 0 or a1 >= len(adj_matrix[a3]) or adj_matrix[a3][a1] != '1':
+                return False
+            return True