init-commit

internbootcamp/bootcamp/cvulnerablekerbals/cvulnerablekerbals.py

@@ -0,0 +1,277 @@
+"""# 
+
+### 谜题描述
+You are given an integer m, and a list of n distinct integers between 0 and m - 1.
+
+You would like to construct a sequence satisfying the properties:
+
+  * Each element is an integer between 0 and m - 1, inclusive. 
+  * All prefix products of the sequence modulo m are distinct. 
+  * No prefix product modulo m appears as an element of the input list. 
+  * The length of the sequence is maximized. 
+
+
+
+Construct any sequence satisfying the properties above.
+
+Input
+
+The first line of input contains two integers n and m (0 ≤ n < m ≤ 200 000) — the number of forbidden prefix products and the modulus.
+
+If n is non-zero, the next line of input contains n distinct integers between 0 and m - 1, the forbidden prefix products. If n is zero, this line doesn't exist.
+
+Output
+
+On the first line, print the number k, denoting the length of your sequence.
+
+On the second line, print k space separated integers, denoting your sequence.
+
+Examples
+
+Input
+
+0 5
+
+
+Output
+
+5
+1 2 4 3 0
+
+
+Input
+
+3 10
+2 9 1
+
+
+Output
+
+6
+3 9 2 9 8 0
+
+Note
+
+For the first case, the prefix products of this sequence modulo m are [1, 2, 3, 4, 0].
+
+For the second case, the prefix products of this sequence modulo m are [3, 7, 4, 6, 8, 0].
+
+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 N = 2e5 + 5;
+int n, m, w[N], vis[N], dp[N], pre[N], cnt;
+vector<int> g[N];
+long long exgcd(long long &x, long long &y, long long a, long long b) {
+  if (!b) {
+    x = 1, y = 0;
+    return a;
+  }
+  long long g = exgcd(x, y, b, a % b);
+  long long t = x;
+  x = y;
+  y = t - a / b * y;
+  return g;
+}
+long long getans(long long a, long long b) {
+  long long x, y;
+  long long c = exgcd(x, y, a, m);
+  x = (x * b / c % m + m) % m;
+  return x;
+}
+int main() {
+  long long x, y;
+  scanf(\"%d%d\", &n, &m);
+  for (int i = 1; i <= n; i++) {
+    scanf(\"%lld\", &x);
+    vis[x] = 1;
+  }
+  for (int i = 0; i < m; i++)
+    if (!vis[i]) g[exgcd(x, y, (long long)i, (long long)m)].push_back(i);
+  for (int i = 1; i <= m; i++) {
+    if (m % i) continue;
+    dp[i] += g[i].size();
+    for (int j = i + i; j <= m; j += i) {
+      if (m % j) continue;
+      if (dp[j] <= dp[i]) {
+        dp[j] = dp[i];
+        pre[j] = i;
+      }
+    }
+  }
+  int now = m;
+  while (1) {
+    for (int i = 0; i < (int)g[now].size(); i++) w[cnt++] = g[now][i];
+    if (now == 1) break;
+    now = pre[now];
+  }
+  printf(\"%d\n\", cnt);
+  printf(\"%d \", w[cnt - 1]);
+  for (int i = cnt - 1; i; i--) printf(\"%lld \", getans(w[i], w[i - 1]));
+  return 0;
+}
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import re
+import math
+import random
+from collections import defaultdict
+from bootcamp import Basebootcamp
+
+def exgcd(a, b):
+    if b == 0:
+        return (a, 1, 0)
+    else:
+        g, x, y = exgcd(b, a % b)
+        return (g, y, x - (a // b) * y)
+
+def generate_solution_for_m(m):
+    vis = set()
+    g = defaultdict(list)
+    for i in range(m):
+        if i not in vis:
+            g_val = math.gcd(i, m)
+            g[g_val].append(i)
+    
+    divisors = [d for d in range(1, m + 1) if m % d == 0]
+    divisors.sort()
+    
+    dp = {d: 0 for d in divisors}
+    pre = {d: None for d in divisors}
+    
+    for d in divisors:
+        dp[d] = len(g.get(d, []))
+        j = 2 * d
+        while j <= m:
+            if j not in divisors:
+                j += d
+                continue
+            if dp[j] < dp[d]:
+                dp[j] = dp[d]
+                pre[j] = d
+            elif dp[j] == dp[d]:
+                if pre[j] is None or pre[j] < d:
+                    pre[j] = d
+            j += d
+    
+    current_d = m
+    w = []
+    while True:
+        w.extend(g.get(current_d, []))
+        if current_d == 1:
+            break
+        current_d = pre.get(current_d)
+        if current_d is None:
+            break
+    
+    if not w:
+        return 0, []
+    
+    sequence = []
+    sequence.append(w[-1])
+    for i in range(len(w)-1, 0, -1):
+        a = w[i]
+        b = w[i-1]
+        g_val, x, y = exgcd(a, m)
+        assert b % g_val == 0, "No solution"
+        x0 = (x * (b // g_val)) % (m // g_val)
+        sequence.append(x0)
+    
+    current = 1
+    prefix_products = []
+    for num in sequence:
+        current = (current * num) % m
+        prefix_products.append(current)
+    
+    return len(sequence), prefix_products
+
+class Cvulnerablekerbalsbootcamp(Basebootcamp):
+    def __init__(self, m_min=2, m_max=20):
+        self.m_min = m_min
+        self.m_max = m_max
+    
+    def case_generator(self):
+        m = random.randint(self.m_min, self.m_max)
+        k_max, P = generate_solution_for_m(m)
+        all_numbers = set(range(m))
+        P_set = set(P)
+        C = list(all_numbers - P_set)
+        max_n = min(len(C), m-1)
+        n = random.randint(0, max_n) if max_n >= 0 else 0
+        L = random.sample(C, n) if n > 0 else []
+        L.sort()
+        return {
+            'm': m,
+            'n': n,
+            'forbidden': L,
+            'k_max': k_max
+        }
+    
+    @staticmethod
+    def prompt_func(question_case):
+        m = question_case['m']
+        n = question_case['n']
+        forbidden = question_case['forbidden']
+        problem = f"You are given an integer m and a list of n distinct integers between 0 and m-1.\n\n"
+        problem += "Your task is to construct a sequence satisfying the following properties:\n"
+        problem += "1. Each element is an integer between 0 and m-1, inclusive.\n"
+        problem += "2. All prefix products of the sequence modulo m are distinct.\n"
+        problem += "3. No prefix product modulo m appears in the forbidden list.\n"
+        problem += "4. The length of the sequence is maximized.\n\n"
+        problem += "Input:\n"
+        problem += f"{n} {m}\n"
+        if n > 0:
+            problem += " ".join(map(str, forbidden)) + "\n"
+        problem += "\nOutput your answer in the following format:\n"
+        problem += "[answer]\n<length>\n<sequence elements space-separated>\n[/answer]"
+        return problem
+    
+    @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()
+        lines = [l.strip() for l in answer.split('\n') if l.strip()]
+        if len(lines) < 2:
+            return None
+        try:
+            k = int(lines[0])
+            elements = list(map(int, lines[1].split()))
+            if len(elements) != k:
+                return None
+            return elements
+        except:
+            return None
+    
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        if solution is None:
+            return False
+        m = identity['m']
+        forbidden = set(identity['forbidden'])
+        k_max = identity['k_max']
+        
+        if len(solution) != k_max:
+            return False
+        
+        for num in solution:
+            if not (0 <= num < m):
+                return False
+        
+        current = 1
+        prefix_products = []
+        for num in solution:
+            current = (current * num) % m
+            if current in forbidden or current in prefix_products:
+                return False
+            prefix_products.append(current)
+        
+        return True