InternBootcamp/internbootcamp/bootcamp/byetanotherarraypartitioningtask/byetanotherarraypartitioningtask.py

"""# 

### 谜题描述
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