Problem:
Score : 700 points

Problem Statement

There are N panels arranged in a row in Takahashi's house, numbered 1 through N. The i-th panel has a number A_i written on it. Takahashi is playing by throwing balls at these panels.

Takahashi threw a ball K times. Let the panel hit by a boll in the i-th throw be panel p_i. He set the score for the i-th throw as i \times A_{p_i}.

He was about to calculate the total score for his throws, when he realized that he forgot the panels hit by balls, p_1,p_2,...,p_K. The only fact he remembers is that for every i (1 ≦ i ≦ K-1), 1 ≦ p_{i+1}-p_i ≦ M holds. Based on this fact, find the maximum possible total score for his throws.

Constraints

1 ≦ M ≦ N ≦ 100,000

1 ≦ K ≦ min(300,N)

1 ≦ A_i ≦ 10^{9}

Partial Scores

In the test set worth 100 points, M = N.

In the test set worth another 200 points, N ≦ 300 and K ≦ 30.

In the test set worth another 300 points, K ≦ 30.

Input

The input is given from Standard Input in the following format:

N M K
A_1 A_2 … A_N

Output

Print the maximum possible total score for Takahashi's throws.

Sample Input 1

5 2 3
10 2 8 10 2

Sample Output 1

56

The total score is maximized when panels 1,3 and 4 are hit, in this order.

Sample Input 2

5 5 2
5 2 10 5 9

Sample Output 2

28

This case satisfies the additional constraint M = N for a partial score.

Sample Input 3

10 3 5
3 7 2 6 9 4 8 5 1 1000000000

Sample Output 3

5000000078

Solution in C (GCC 5.4.1) (judge verdict: Accepted)

#include<stdio.h>
#include<stdlib.h>
#include<stdint.h>
#include<inttypes.h>

typedef int32_t i32;
typedef int64_t i64;

#define MAX(a,b) ((a)>(b)?(a):(b))
#define ALLOC(size,type) ((type*)calloc((size),sizeof(type)))

typedef struct index_val {
  i32 k;
  i64 v;
} node;

void run (void) {
  i32 n, m, k;
  scanf ("%" SCNi32 "%" SCNi32 "%" SCNi32, &n, &m, &k);
  i32 *a = ALLOC (n, i32);
  for (i32 i = 0; i < n; ++i) {
    scanf ("%" SCNi32, a + i);
  }
  i64 *dp = ALLOC (n, i64);
  for (i32 i = 0; i < n; ++i) {
    dp[i] = a[i];
  }
  node *d = ALLOC (n, node);
  for (i32 i = 2; i <= k; ++i) {
    i32 f = 0;
    i32 b = 0;
    d[0] = (node){i - 2, dp[i - 2]};
    for (i32 j = i - 1; j < n; ++j) {
      if (d[f].k == j - m - 1) ++f;
      i64 v = d[f].v + (i64) i * a[j];
      while (f <= b && d[b].v <= dp[j]) --b;
      d[++b] = (node) {j, dp[j]};
      dp[j] = v;
    }
  }
  i64 ans = 0;
  for (i32 i = k - 1; i < n; ++i) {
    if (ans < dp[i]) {
      ans = dp[i];
    }
  }
  printf("%" PRIi64 "\n", ans);
}

int main (void) {
  run();
  return 0;
}