init-commit

internbootcamp/bootcamp/cnastyaistransposingmatrices/cnastyaistransposingmatrices.py

@@ -0,0 +1,235 @@
+"""# 
+
+### 谜题描述
+Nastya came to her informatics lesson, and her teacher who is, by the way, a little bit famous here gave her the following task.
+
+Two matrices A and B are given, each of them has size n × m. Nastya can perform the following operation to matrix A unlimited number of times: 
+
+  * take any square square submatrix of A and transpose it (i.e. the element of the submatrix which was in the i-th row and j-th column of the submatrix will be in the j-th row and i-th column after transposing, and the transposed submatrix itself will keep its place in the matrix A). 
+
+
+
+Nastya's task is to check whether it is possible to transform the matrix A to the matrix B.
+
+<image> Example of the operation
+
+As it may require a lot of operations, you are asked to answer this question for Nastya.
+
+A square submatrix of matrix M is a matrix which consist of all elements which comes from one of the rows with indeces x, x+1, ..., x+k-1 of matrix M and comes from one of the columns with indeces y, y+1, ..., y+k-1 of matrix M. k is the size of square submatrix. In other words, square submatrix is the set of elements of source matrix which form a solid square (i.e. without holes).
+
+Input
+
+The first line contains two integers n and m separated by space (1 ≤ n, m ≤ 500) — the numbers of rows and columns in A and B respectively.
+
+Each of the next n lines contains m integers, the j-th number in the i-th of these lines denotes the j-th element of the i-th row of the matrix A (1 ≤ A_{ij} ≤ 10^{9}).
+
+Each of the next n lines contains m integers, the j-th number in the i-th of these lines denotes the j-th element of the i-th row of the matrix B (1 ≤ B_{ij} ≤ 10^{9}).
+
+Output
+
+Print \"YES\" (without quotes) if it is possible to transform A to B and \"NO\" (without quotes) otherwise.
+
+You can print each letter in any case (upper or lower).
+
+Examples
+
+Input
+
+
+2 2
+1 1
+6 1
+1 6
+1 1
+
+
+Output
+
+
+YES
+
+Input
+
+
+2 2
+4 4
+4 5
+5 4
+4 4
+
+
+Output
+
+
+NO
+
+Input
+
+
+3 3
+1 2 3
+4 5 6
+7 8 9
+1 4 7
+2 5 6
+3 8 9
+
+
+Output
+
+
+YES
+
+Note
+
+Consider the third example. The matrix A initially looks as follows.
+
+$$$ \begin{bmatrix} 1 & 2 & 3\\\ 4 & 5 & 6\\\ 7 & 8 & 9 \end{bmatrix} $$$
+
+Then we choose the whole matrix as transposed submatrix and it becomes
+
+$$$ \begin{bmatrix} 1 & 4 & 7\\\ 2 & 5 & 8\\\ 3 & 6 & 9 \end{bmatrix} $$$
+
+Then we transpose the submatrix with corners in cells (2, 2) and (3, 3). 
+
+$$$ \begin{bmatrix} 1 & 4 & 7\\\ 2 & 5 & 8\\\ 3 & 6 & 9 \end{bmatrix} $$$
+
+So matrix becomes
+
+$$$ \begin{bmatrix} 1 & 4 & 7\\\ 2 & 5 & 6\\\ 3 & 8 & 9 \end{bmatrix} $$$
+
+and it is B.
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+n, m = map(int, raw_input().split())
+
+a = []
+for i in range(n):
+    a.append(map(int, raw_input().split()))
+
+b = []
+for i in range(n):
+    b.append(map(int, raw_input().split()))
+
+z = 'YES'
+for t in range(n + m - 1):
+    if t < n:
+        i = t
+        j = 0
+    else:
+        i = n - 1
+        j = t - n + 1
+
+    pa = []
+    pb = []
+    while i >= 0 and j < m:
+        pa.append(a[i][j])
+        pb.append(b[i][j])
+        i -= 1
+        j += 1
+
+    pa.sort()
+    pb.sort()
+    for i in range(len(pa)):
+        if pa[i] != pb[i]: z = 'NO'
+
+    if z == 'NO': break
+
+print z
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+import re
+from bootcamp import Basebootcamp
+
+class Cnastyaistransposingmatricesbootcamp(Basebootcamp):
+    def __init__(self, **params):
+        self.n = params.get('n', 3)
+        self.m = params.get('m', 3)
+        self.ensure_solvable = params.get('ensure_solvable', True)  # 参数命名更明确
+    
+    def case_generator(self):
+        n, m = self.n, self.m
+        B = [[random.randint(1, 100) for _ in range(m)] for _ in range(n)]
+        A = [[0]*m for _ in range(n)]
+
+        # 按斜对角线处理元素
+        for t in range(n + m -1):
+            coords = []
+            if t < n:
+                i, j = t, 0
+            else:
+                i, j = n-1, t - n +1
+            
+            while i >= 0 and j < m:
+                coords.append((i, j))
+                i -= 1
+                j += 1
+
+            b_elements = [B[x][y] for x, y in coords]
+            a_elements = random.sample(b_elements, len(b_elements))  # 确保元素完全重排
+
+            for idx, (x, y) in enumerate(coords):
+                A[x][y] = a_elements[idx]
+
+        # 生成错误案例的增强逻辑
+        if not self.ensure_solvable:
+            diagonal_id = random.randint(0, n + m -2)
+            coords = self._get_diagonal_coords(diagonal_id, n, m)
+            if coords:
+                x, y = random.choice(coords)
+                while True:
+                    new_val = A[x][y] + random.choice([-1, 1])
+                    if new_val != A[x][y] and new_val > 0:
+                        A[x][y] = new_val
+                        break
+
+        return {'n':n, 'm':m, 'A':A, 'B':B}
+
+    @staticmethod
+    def _get_diagonal_coords(t, n, m):
+        coords = []
+        if t < n:
+            i, j = t, 0
+        else:
+            i, j = n-1, t - n +1
+        
+        while i >=0 and j < m:
+            coords.append((i, j))
+            i -= 1
+            j += 1
+        return coords
+
+    @staticmethod
+    def prompt_func(question_case) -> str:
+        matrix_text = lambda m: '\n'.join([f"Row {i+1}: {' '.join(map(str, row))}" for i, row in enumerate(m)])
+        return f"""Determine if matrix A can be transformed into matrix B using square submatrix transposes. 
+
+Matrix A:
+{matrix_text(question_case['A'])}
+
+Matrix B:
+{matrix_text(question_case['B'])}
+
+Answer must be uppercase 'YES' or 'NO' within [answer] tags."""
+
+    @staticmethod
+    def extract_output(output):
+        answers = re.findall(r'\[answer\](YES|NO)\[/answer\]', output, re.IGNORECASE)
+        return answers[-1].upper() if answers else None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        for t in range(identity['n'] + identity['m'] -1):
+            coords = cls._get_diagonal_coords(t, identity['n'], identity['m'])
+            a_values = [identity['A'][x][y] for x, y in coords]
+            b_values = [identity['B'][x][y] for x, y in coords]
+            if sorted(a_values) != sorted(b_values):
+                return solution == 'NO'
+        return solution == 'YES'