init-commit

internbootcamp/bootcamp/bminimization/bminimization.py

@@ -0,0 +1,225 @@
+"""# 
+
+### 谜题描述
+You've got array A, consisting of n integers and a positive integer k. Array A is indexed by integers from 1 to n.
+
+You need to permute the array elements so that value 
+
+<image> became minimal possible. In particular, it is allowed not to change order of elements at all.
+
+Input
+
+The first line contains two integers n, k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ min(5000, n - 1)). 
+
+The second line contains n integers A[1], A[2], ..., A[n] ( - 109 ≤ A[i] ≤ 109), separate by spaces — elements of the array A.
+
+Output
+
+Print the minimum possible value of the sum described in the statement.
+
+Examples
+
+Input
+
+3 2
+1 2 4
+
+
+Output
+
+1
+
+
+Input
+
+5 2
+3 -5 3 -5 3
+
+
+Output
+
+0
+
+
+Input
+
+6 3
+4 3 4 3 2 5
+
+
+Output
+
+3
+
+Note
+
+In the first test one of the optimal permutations is 1 4 2. 
+
+In the second test the initial order is optimal. 
+
+In the third test one of the optimal permutations is 2 3 4 4 3 5.
+
+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
+#import random
+#sys.setrecursionlimit(99999999)
+def i(): return sys.stdin.readline().strip().split(\" \")
+_=i()
+n,k=int(_[0]),int(_[1])
+numbers=map(int,i())
+#numbers=[random.randint(-1000000000,1000000000) for e in xrange(n)]
+numbers.sort()
+#numbers.append(numbers[-1])
+diff=[numbers[0]]
+for e in xrange(n-1):
+    diff.append(numbers[e+1]-numbers[e])
+diff.append(0)
+addingOne=n%k
+visited=[[0]*(k+1) for e in xrange(addingOne+1)]
+for e in xrange(1,k+1):
+    visited[0][e]=diff[0+e*(n/k)]+max(visited[0][e-1],0)
+for a in xrange(1,addingOne+1):
+    for b in xrange(a,k+1):
+        #print a,b
+        visited[a][b]=diff[a+b*(n/k)]+max(visited[a-1][b-1],visited[a][b-1])
+print numbers[-1]-numbers[0]-visited[addingOne][k]
+```
+
+
+请完成上述谜题的训练场环境类实现，包括所有必要的方法。
+"""
+
+from bootcamp import Basebootcamp
+import random
+import re
+from bootcamp import Basebootcamp
+
+class Bminimizationbootcamp(Basebootcamp):
+    def __init__(self, min_n=2, max_n=10, min_k=1, max_k=None, min_val=-100, max_val=100):
+        self.min_n = min_n
+        self.max_n = max_n
+        self.min_k = min_k
+        self.max_k = max_k
+        self.min_val = min_val
+        self.max_val = max_val
+
+    def case_generator(self):
+        n = random.randint(self.min_n, self.max_n)
+        max_k_candidate = min(5000, n - 1)
+        if self.max_k is None:
+            max_k = max_k_candidate
+        else:
+            max_k = min(self.max_k, max_k_candidate)
+        min_k = max(1, self.min_k)
+        max_k = max(min_k, max_k)
+        k = random.randint(min_k, max_k)
+        A = [random.randint(self.min_val, self.max_val) for _ in range(n)]
+        return {
+            'n': n,
+            'k': k,
+            'A': A.copy()
+        }
+
+    @staticmethod
+    def prompt_func(question_case):
+        n = question_case['n']
+        k = question_case['k']
+        A = question_case['A']
+        return f"""You are given an array A of {n} integers and a positive integer k. Your task is to find the minimal possible value of S after optimally permuting the array. 
+
+**Problem Details:**
+- Array A has the elements: {', '.join(map(str, A))}.
+- The integer k is {k}.
+
+**Rules:**
+1. Permute the array into any order.
+2. Sort the permuted array in non-decreasing order.
+3. Split the sorted array into (k+1) consecutive non-empty subarrays by selecting k split points.
+4. The sum of the differences at the split points is the sum of the values (first element of next subarray - last element of current subarray) for each split point.
+5. The value S is the total range of the sorted array (maximum element - minimum element) minus this sum of differences.
+
+Your goal is to compute the minimal possible value of S.
+
+**Answer Format:**
+Place your answer within [answer] and [/answer], like [answer]42[/answer]. Ensure it's the only occurrence and correctly formatted.
+
+Example Answer:
+For Input:
+3 2
+1 2 4
+The correct answer is [answer]1[/answer].
+
+Now, solve the following problem:
+n = {n}, k = {k}, array A = {A}
+What is the minimal possible value of S?"""
+
+    @staticmethod
+    def extract_output(output):
+        matches = re.findall(r'\[answer\](.*?)\[/answer\]', output, re.DOTALL)
+        if not matches:
+            return None
+        last_match = matches[-1].strip()
+        try:
+            return int(last_match)
+        except ValueError:
+            try:
+                return float(last_match)
+            except:
+                return None
+
+    @classmethod
+    def _verify_correction(cls, solution, identity):
+        n = identity['n']
+        k = identity['k']
+        A = identity['A']
+        correct = cls.compute_min_sum(n, k, A)
+        return solution == correct
+
+    @staticmethod
+    def compute_min_sum(n, k, A):
+        numbers = sorted(A)
+        if n == 0:
+            return 0
+        if k == 0:
+            return numbers[-1] - numbers[0]
+
+        adding_one = n % k
+        part_length = n // k
+        total_groups = k + 1
+
+        # 构建差分数组（注意索引偏移）
+        diff = []
+        for i in range(n-1):
+            diff.append(numbers[i+1] - numbers[i])
+        
+        # 动态规划初始化
+        dp = [[0]*(k+1) for _ in range(adding_one+1)]
+        
+        # 预处理第一个分割点
+        for e in range(1, k+1):
+            pos = (e-1)*part_length
+            if pos >= len(diff):
+                val = 0
+            else:
+                val = diff[pos]
+            dp[0][e] = dp[0][e-1] + val
+
+        # 处理添加额外元素的分割
+        for a in range(1, adding_one+1):
+            for e in range(1, k+1):
+                if e < a: continue
+                pos = (e-1)*part_length + a
+                if pos >= len(diff):
+                    val = 0
+                else:
+                    val = diff[pos]
+                
+                if a == e:
+                    dp[a][e] = dp[a-1][e-1] + val
+                else:
+                    dp[a][e] = max(dp[a-1][e-1], dp[a][e-1]) + val
+
+        max_sum_diff = dp[adding_one][k]
+        total_range = numbers[-1] - numbers[0]
+        return total_range - max_sum_diff