mirror of
https://github.com/InternLM/InternBootcamp.git
synced 2026-04-19 12:58:04 +00:00
init-commit
This commit is contained in:
lilinyang
commit
18a552597a
3461 changed files with 1150579 additions and 0 deletions
|
|
@ -0,0 +1,256 @@
|
|||
"""#
|
||||
|
||||
### 谜题描述
|
||||
An array b is called to be a subarray of a if it forms a continuous subsequence of a, that is, if it is equal to a_l, a_{l + 1}, …, a_r for some l, r.
|
||||
|
||||
Suppose m is some known constant. For any array, having m or more elements, let's define it's beauty as the sum of m largest elements of that array. For example:
|
||||
|
||||
* For array x = [4, 3, 1, 5, 2] and m = 3, the 3 largest elements of x are 5, 4 and 3, so the beauty of x is 5 + 4 + 3 = 12.
|
||||
* For array x = [10, 10, 10] and m = 2, the beauty of x is 10 + 10 = 20.
|
||||
|
||||
|
||||
|
||||
You are given an array a_1, a_2, …, a_n, the value of the said constant m and an integer k. Your need to split the array a into exactly k subarrays such that:
|
||||
|
||||
* Each element from a belongs to exactly one subarray.
|
||||
* Each subarray has at least m elements.
|
||||
* The sum of all beauties of k subarrays is maximum possible.
|
||||
|
||||
Input
|
||||
|
||||
The first line contains three integers n, m and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m, 2 ≤ k, m ⋅ k ≤ n) — the number of elements in a, the constant m in the definition of beauty and the number of subarrays to split to.
|
||||
|
||||
The second line contains n integers a_1, a_2, …, a_n (-10^9 ≤ a_i ≤ 10^9).
|
||||
|
||||
Output
|
||||
|
||||
In the first line, print the maximum possible sum of the beauties of the subarrays in the optimal partition.
|
||||
|
||||
In the second line, print k-1 integers p_1, p_2, …, p_{k-1} (1 ≤ p_1 < p_2 < … < p_{k-1} < n) representing the partition of the array, in which:
|
||||
|
||||
* All elements with indices from 1 to p_1 belong to the first subarray.
|
||||
* All elements with indices from p_1 + 1 to p_2 belong to the second subarray.
|
||||
* ….
|
||||
* All elements with indices from p_{k-1} + 1 to n belong to the last, k-th subarray.
|
||||
|
||||
|
||||
|
||||
If there are several optimal partitions, print any of them.
|
||||
|
||||
Examples
|
||||
|
||||
Input
|
||||
|
||||
|
||||
9 2 3
|
||||
5 2 5 2 4 1 1 3 2
|
||||
|
||||
|
||||
Output
|
||||
|
||||
|
||||
21
|
||||
3 5
|
||||
|
||||
Input
|
||||
|
||||
|
||||
6 1 4
|
||||
4 1 3 2 2 3
|
||||
|
||||
|
||||
Output
|
||||
|
||||
|
||||
12
|
||||
1 3 5
|
||||
|
||||
Input
|
||||
|
||||
|
||||
2 1 2
|
||||
-1000000000 1000000000
|
||||
|
||||
|
||||
Output
|
||||
|
||||
|
||||
0
|
||||
1
|
||||
|
||||
Note
|
||||
|
||||
In the first example, one of the optimal partitions is [5, 2, 5], [2, 4], [1, 1, 3, 2].
|
||||
|
||||
* The beauty of the subarray [5, 2, 5] is 5 + 5 = 10.
|
||||
* The beauty of the subarray [2, 4] is 2 + 4 = 6.
|
||||
* The beauty of the subarray [1, 1, 3, 2] is 3 + 2 = 5.
|
||||
|
||||
|
||||
|
||||
The sum of their beauties is 10 + 6 + 5 = 21.
|
||||
|
||||
In the second example, one optimal partition is [4], [1, 3], [2, 2], [3].
|
||||
|
||||
Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution.
|
||||
```python
|
||||
from __future__ import division, print_function
|
||||
from sys import stdin, stdout
|
||||
|
||||
|
||||
def write(x):
|
||||
stdout.write(str(x) + \"\n\")
|
||||
|
||||
|
||||
n, m, k = map(int, stdin.readline().split())
|
||||
a = map(int, stdin.readline().split())
|
||||
|
||||
asort = sorted(a, reverse=True)
|
||||
cut = m * k - 1
|
||||
out = []
|
||||
currentin = 0
|
||||
for i in xrange(len(a)):
|
||||
if a[i] >= asort[cut]:
|
||||
if a[i] == asort[cut]:
|
||||
cut -= 1
|
||||
currentin += 1
|
||||
if currentin == m:
|
||||
out.append(i + 1)
|
||||
currentin = 0
|
||||
if len(out) + 1 == k:
|
||||
break
|
||||
|
||||
write(sum(asort[:m * k]))
|
||||
print(*out)
|
||||
```
|
||||
|
||||
|
||||
请完成上述谜题的训练场环境类实现，包括所有必要的方法。
|
||||
"""
|
||||
|
||||
from bootcamp import Basebootcamp
|
||||
import random
|
||||
from bootcamp import Basebootcamp
|
||||
|
||||
class Byetanotherarraypartitioningtaskbootcamp(Basebootcamp):
|
||||
def __init__(self, max_n=20, max_m=3, max_k=4):
|
||||
self.max_n = max_n
|
||||
self.max_m = max_m
|
||||
self.max_k = max_k
|
||||
|
||||
def case_generator(self):
|
||||
for _ in range(1000): # 防止无限循环，最多尝试1000次
|
||||
m = random.randint(1, self.max_m)
|
||||
k = random.randint(2, self.max_k)
|
||||
if m * k > self.max_n:
|
||||
continue
|
||||
n = random.randint(m * k, self.max_n)
|
||||
a_top = [random.randint(50, 100) for _ in range(m * k)]
|
||||
a_rest = [random.randint(-100, 0) for _ in range(n - m * k)]
|
||||
a = a_top + a_rest
|
||||
random.shuffle(a)
|
||||
sum_answer, partitions = self.generate_solution(a, m, k)
|
||||
if len(partitions) == k - 1:
|
||||
return {
|
||||
'n': n,
|
||||
'm': m,
|
||||
'k': k,
|
||||
'a': a,
|
||||
'sum_answer': sum_answer,
|
||||
'partitions': partitions
|
||||
}
|
||||
raise ValueError("Unable to generate valid test case after 1000 attempts")
|
||||
|
||||
@staticmethod
|
||||
def generate_solution(a, m, k):
|
||||
asort = sorted(a, reverse=True)
|
||||
total_sum = sum(asort[:m * k])
|
||||
cut = m * k - 1
|
||||
out = []
|
||||
currentin = 0
|
||||
for i in range(len(a)):
|
||||
# 防止cut越界
|
||||
if cut >= 0 and a[i] >= asort[cut]:
|
||||
if a[i] == asort[cut]:
|
||||
cut -= 1
|
||||
currentin += 1
|
||||
if currentin == m:
|
||||
out.append(i + 1)
|
||||
currentin = 0
|
||||
if len(out) == k - 1:
|
||||
break
|
||||
return total_sum, out
|
||||
|
||||
@staticmethod
|
||||
def prompt_func(question_case) -> str:
|
||||
input_lines = [
|
||||
f"{question_case['n']} {question_case['m']} {question_case['k']}",
|
||||
' '.join(map(str, question_case['a']))
|
||||
]
|
||||
input_str = '\n'.join(input_lines)
|
||||
return f"""You are a competitive programmer. Solve the subarray partition problem by splitting the array into exactly {question_case['k']} subarrays, each with at least {question_case['m']} elements. The beauty of each subarray is the sum of its {question_case['m']} largest elements. Find the maximum total beauty and the partition points.
|
||||
|
||||
Input:
|
||||
{input_str}
|
||||
|
||||
Output the maximum sum on the first line and the partition points (k-1 integers) on the second line. Enclose your answer within [answer] and [/answer]. For example:
|
||||
[answer]
|
||||
42
|
||||
1 3 5
|
||||
[/answer]
|
||||
"""
|
||||
|
||||
@staticmethod
|
||||
def extract_output(output):
|
||||
import re
|
||||
matches = re.findall(r'\[answer\](.*?)\[\/answer\]', output, re.DOTALL)
|
||||
if not matches:
|
||||
return None
|
||||
last_match = matches[-1].strip()
|
||||
lines = [line.strip() for line in last_match.split('\n') if line.strip()]
|
||||
if len(lines) < 2:
|
||||
return None
|
||||
try:
|
||||
sum_answer = int(lines[0])
|
||||
partitions = list(map(int, lines[1].split()))
|
||||
except:
|
||||
return None
|
||||
return (sum_answer, partitions)
|
||||
|
||||
@classmethod
|
||||
def _verify_correction(cls, solution, identity):
|
||||
if not solution or len(solution) != 2:
|
||||
return False
|
||||
sum_user, partitions = solution
|
||||
k = identity['k']
|
||||
n = identity['n']
|
||||
m = identity['m']
|
||||
# 检查总和是否正确
|
||||
if sum_user != identity['sum_answer']:
|
||||
return False
|
||||
# 检查分割点数量
|
||||
if len(partitions) != k - 1:
|
||||
return False
|
||||
# 检查分割点是否递增且在合理范围
|
||||
prev = 0
|
||||
for p in partitions:
|
||||
if p <= prev or p < 1 or p >= n:
|
||||
return False
|
||||
prev = p
|
||||
# 检查每个子数组长度至少m
|
||||
current_start = 0
|
||||
for p in partitions + [n]:
|
||||
sub_length = p - current_start
|
||||
if sub_length < m:
|
||||
return False
|
||||
current_start = p
|
||||
# 检查实际总和是否匹配
|
||||
current_start = 0
|
||||
total = 0
|
||||
a = identity['a']
|
||||
for p in partitions + [n]:
|
||||
sub = a[current_start:p]
|
||||
sorted_sub = sorted(sub, reverse=True)
|
||||
total += sum(sorted_sub[:m])
|
||||
current_start = p
|
||||
return total == sum_user
|
||||
Loading…
Add table
Add a link
Reference in a new issue