init-commit

internbootcamp/bootcamp/cgargariandbishops/cgargariandbishops.py

@@ -0,0 +1,194 @@
+"""# 
+
+### 谜题描述
+Gargari is jealous that his friend Caisa won the game from the previous problem. He wants to prove that he is a genius.
+
+He has a n × n chessboard. Each cell of the chessboard has a number written on it. Gargari wants to place two bishops on the chessboard in such a way that there is no cell that is attacked by both of them. Consider a cell with number x written on it, if this cell is attacked by one of the bishops Gargari will get x dollars for it. Tell Gargari, how to place bishops on the chessboard to get maximum amount of money.
+
+We assume a cell is attacked by a bishop, if the cell is located on the same diagonal with the bishop (the cell, where the bishop is, also considered attacked by it).
+
+Input
+
+The first line contains a single integer n (2 ≤ n ≤ 2000). Each of the next n lines contains n integers aij (0 ≤ aij ≤ 109) — description of the chessboard.
+
+Output
+
+On the first line print the maximal number of dollars Gargari will get. On the next line print four integers: x1, y1, x2, y2 (1 ≤ x1, y1, x2, y2 ≤ n), where xi is the number of the row where the i-th bishop should be placed, yi is the number of the column where the i-th bishop should be placed. Consider rows are numbered from 1 to n from top to bottom, and columns are numbered from 1 to n from left to right.
+
+If there are several optimal solutions, you can print any of them.
+
+Examples
+
+Input
+
+4
+1 1 1 1
+2 1 1 0
+1 1 1 0
+1 0 0 1
+
+
+Output
+
+12
+2 2 3 2
+
+Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
+```python
+import sys 
+input=sys.stdin.readline 
+n=int(input())
+mat=[]
+
+for i in range(n):
+    mat.append([int(i) for i in input().split()])
+pri=[0]*(2*n+1)
+sec=[0]*(2*n+1)
+for i in range(n):
+    for j in range(n):
+        pri[i-j+n]+=mat[i][j]
+        sec[i+j]+=mat[i][j]
+resw=-1 
+resb=-1 
+indw=[]
+indb=[]
+for i in range(n):
+    for j in range(n):
+        curr=pri[i-j+n]+sec[i+j]-mat[i][j]
+        if (i+j)&1:
+            #i am blck 
+            if curr>resb:
+                resb=curr 
+                indb=[i+1,j+1]
+        else: 
+            if curr>resw:
+                resw=curr 
+                indw=[i+1,j+1]
+print(resw+resb)
+print indb[0],indb[1],
+print indw[0],indw[1]
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+import re
+from bootcamp import Basebootcamp
+
+class Cgargariandbishopsbootcamp(Basebootcamp):
+    def __init__(self, n=4, min_val=0, max_val=10):
+        if n < 2:
+            raise ValueError("n must be at least 2")
+        self.n = n
+        self.min_val = min_val
+        self.max_val = max_val
+
+    def case_generator(self):
+        n = self.n
+        mat = [[random.randint(self.min_val, self.max_val) for _ in range(n)] for _ in range(n)]
+        
+        # 正确初始化对角线数组
+        pri = [0] * (2 * n)     # 主对角线 (i-j) 范围：-(n-1) 到 (n-1) → 索引范围：1 到 2n-1
+        sec = [0] * (2 * n - 1)  # 副对角线 (i+j) 范围：0 到 2n-2
+        
+        for i in range(n):
+            for j in range(n):
+                pri_index = i - j + n
+                sec_index = i + j
+                pri[pri_index] += mat[i][j]
+                sec[sec_index] += mat[i][j]
+        
+        # 计算各颜色最大贡献
+        white_max = -1
+        black_max = -1
+        white_positions = []
+        black_positions = []
+        
+        for i in range(n):
+            for j in range(n):
+                total = pri[i-j+n] + sec[i+j] - mat[i][j]
+                if (i + j) % 2 == 0:  # 白格
+                    if total > white_max:
+                        white_max = total
+                        white_positions = [(i+1, j+1)]
+                    elif total == white_max:
+                        white_positions.append((i+1, j+1))
+                else:                 # 黑格
+                    if total > black_max:
+                        black_max = total
+                        black_positions = [(i+1, j+1)]
+                    elif total == black_max:
+                        black_positions.append((i+1, j+1))
+        
+        return {
+            'n': n,
+            'mat': mat,
+            'white_positions': white_positions,
+            'black_positions': black_positions,
+            'correct_total': white_max + black_max
+        }
+
+    @staticmethod
+    def prompt_func(question_case):
+        mat_str = '\n'.join(' '.join(map(str, row)) for row in question_case['mat'])
+        return f"""Place two bishops on a {question_case['n']}x{question_case['n']} chessboard to maximize attack value without overlapping coverage. 
+
+**Rules**:
+- Bishops attack diagonally (including current cell)
+- Overlapping cells count only once
+- Output format:
+[answer]
+{{total_value}}
+{{x1 y1 x2 y2}}
+[/answer]
+
+**Chessboard**:
+{mat_str}"""
+
+    @staticmethod
+    def extract_output(output):
+        matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
+        if not matches:
+            return None
+        try:
+            parts = matches[-1].strip().split()
+            total = int(parts[0])
+            coords = list(map(int, parts[1:5]))
+            if len(coords) != 4:
+                return None
+            return (total, *coords)
+        except:
+            return None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        try:
+            total, x1, y1, x2, y2 = solution
+        except:
+            return False
+        
+        # 基础验证
+        if total != identity['correct_total']:
+            return False
+        if not all(1 <= v <= identity['n'] for v in [x1, y1, x2, y2]):
+            return False
+        if (x1, y1) == (x2, y2):
+            return False
+        
+        # 转换为0-based坐标
+        i1, j1 = x1-1, y1-1
+        i2, j2 = x2-1, y2-1
+        
+        # 颜色校验
+        if (i1 + j1) % 2 == (i2 + j2) % 2:
+            return False
+        
+        # 候选位置校验
+        pos1, pos2 = (x1, y1), (x2, y2)
+        white_valid = pos1 in identity['white_positions'] and pos2 in identity['black_positions']
+        black_valid = pos1 in identity['black_positions'] and pos2 in identity['white_positions']
+        
+        return white_valid or black_valid