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# (.NET Core 3.1.201) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Numerics;
using System.Linq;
using static System.Math;

class MainClass
{

    public static void Main(string[] args)
    {
        var N = LnInt();
        var As = new List<int[]>();
        var _ = LnInts();
        var counter0 = 0;
        foreach (var i in _)
        {
            As.Add(new[] { counter0, i });
            counter0++;
        }
        var en = As.OrderByDescending(x => x[1]);
        foreach (var i in en) Console.Write(i[1]);
        As = en.ToList();

        var newPlaces = Enumerable.Repeat(-1, N).ToArray();
        for (int i = 0; i < N; i++)
        {
            var min = 0;
            var max = 0;
            var counter = 0;
            foreach (var l in newPlaces) { if (l == -1) { min = counter; counter = N - 1; break; } else { counter++; } }
            foreach (var m in newPlaces.Reverse()) { if (m == -1) { max = counter; break; } else { counter--; } }
            var newIndex = As[i][0] - min > max - As[i][0] ? min : max;
            newPlaces[newIndex] = Abs(As[i][0] - newIndex) * As[i][1];
        }
        var result = 0;
        foreach (var np in newPlaces) { result += np; }
        Console.WriteLine(result);
    }



    public static int[] LnInts()
    {
        var vs = Console.ReadLine().Trim().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
        var ins = new int[vs.Length];
        for (int i = 0; i < vs.Length; i++) ins[i] = int.Parse(vs[i]);
        return ins;
    }

    public static int LnInt()
    {
        var vs = Console.ReadLine().Trim();
        return int.Parse(vs);
    }

    public static string[] LnStrs()
    {
        var vs = Console.ReadLine().Trim().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
        return vs;
    }
    public static string LnStr()
    {
        var vs = Console.ReadLine().Trim();
        return vs;
    }
}