Problem:
Score : 500 points

Problem Statement

There are N children standing in a line from left to right. The activeness of the i-th child from the left is A_i.

You can rearrange these children just one time in any order you like.

When a child who originally occupies the x-th position from the left in the line moves to the y-th position from the left, that child earns A_x \times |x-y| happiness points.

Find the maximum total happiness points the children can earn.

Constraints

2 \leq N \leq 2000

1 \leq A_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the maximum total happiness points the children can earn.

Sample Input 1

4
1 3 4 2

Sample Output 1

20

If we move the 1-st child from the left to the 3-rd position from the left, the 2-nd child to the 4-th position, the 3-rd child to the 1-st position, and the 4-th child to the 2-nd position, the children earns 1 \times |1-3|+3 \times |2-4|+4 \times |3-1|+2 \times |4-2|=20 happiness points in total.

Sample Input 2

6
5 5 6 1 1 1

Sample Output 2

58

Sample Input 3

6
8 6 9 1 2 1

Sample Output 3

85

Solution in C++ (GCC 9.2.1) (judge verdict: Accepted)

#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <functional>
#include <iterator>
#include <numeric>
#include <cstdint>
#include <cmath>
#include <bitset>
#include <string>
#include <list>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>

#define N_TIMES(i, n)     for ( uint64_t i = 0;     i <  n; ++i )
#define N_TIMES_REV(i, n) for (  int64_t i = n - 1; i >= 0; --i )

using namespace std;

struct VectorItem
{
  int64_t key, val;
  VectorItem(int64_t key = 0, int64_t val = 0) : key(key), val(val) {}
  bool operator>(const VectorItem &item) const {
    return val > item.val;
  }
};

int main()
{
  int64_t N;
  cin >> N;

  vector<VectorItem> A(N);
  N_TIMES(n, N) {
    int64_t a;
    cin >> a;

    A[n] = VectorItem(n, a);
  }
  sort(A.begin(), A.end(), greater<VectorItem>());

  vector<vector<int64_t>> dp(N + 1, vector<int64_t>(N + 1, 0));
  for (int64_t n = 0; n < N; ++n) {
    for (int64_t x = 0; x <= n; ++x) {
      int64_t y = n - x;
      dp[x + 1][y] = max(dp[x + 1][y], dp[x][y] + A[n].val * (((N - 1) - x) - A[n].key));
      dp[x][y + 1] = max(dp[x][y + 1], dp[x][y] + A[n].val * (A[n].key - y));
    }
  }

  int64_t ans = 0;
  for (int64_t x = 0; x <= N; ++x) {
    int64_t y = N - x;
    ans = max(ans, dp[x][y]);
  }
  cout << ans << endl;

  return 0;
}