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 Fortran (GNU Fortran 9.2.1) (judge verdict: Wrong Answer)

program main
  implicit none
  type pairtype
    integer :: v, k
  end type pairtype
  integer :: n, i, j, pos
  integer, allocatable :: a(:)
  integer(8), allocatable :: dp(:),  dppre(:)
  type(pairtype), allocatable :: a1(:), a2(:)
  read *, n
  allocate (a(n), a1(n), a2(n), dp(0:n), dppre(0:n))
  read *, a
  do i = 1, n
    a1(i) = pairtype(a(i), i)
  end do
  call quicksort(a1)

  dp(:) = -4 * 10_8 ** 18
  dp(0) = 0
  do i = n, 1, -1
    dppre = dp

    do j = 0, n - i
      ! 左に入れる
      pos = j + 1
      dp(j + 1) = max(dp(j + 1), dppre(j) + (a1(i) % v) * abs(a1(i) % k - pos))

      ! 右に入れる
      pos = i + j
      dp(j) = max(dp(j), dppre(j) + (a1(i) % v) * abs(a1(i) % k - pos))
    end do
  end do

  print "(i0)", maxval(dp)

  contains

  integer(8) function score(a, n)
    integer, intent(in) :: n
    type(pairtype), intent(in) :: a(n)
    integer :: i
    score = 0
    do i = 1, n
      score = score + abs(a(i) % k - i) * a(i) % v
    end do
  end function score

  recursive subroutine quicksort(a)
    type(pairtype), intent(inout) :: a(:)
    type(pairtype) :: pivot, tmp
    integer :: i, j, k, n
    real(4) :: r
    n = size(a)
    if (n <= 1) return
    i = 1
    j = n
    call random_number(r)
    k = 1 + floor(r * n)
    k = max(1, min(k, n))
    pivot = a(k)
    do
      do while (.not. pivot % v <= a(i) % v)
        i = i + 1
      end do
      do while (.not. a(j) % v <= pivot % v)
        j = j - 1
      end do
      if (i >= j) exit
      tmp = a(i)
      a(i) = a(j)
      a(j) = tmp
      i = i + 1
      j = j - 1
    end do
    call quicksort(a(1:i - 1))
    call quicksort(a(j + 1:n))
  end subroutine quicksort
end program main