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 Haskell (GHC 8.8.3) (judge verdict: Accepted)

{-# OPTIONS_GHC -O2 #-}
{-# LANGUAGE BangPatterns, BinaryLiterals, CPP, FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances, KindSignatures, LambdaCase, MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses, MultiWayIf, OverloadedStrings     #-}
{-# LANGUAGE RecordWildCards, ScopedTypeVariables, TupleSections      #-}
{-# LANGUAGE TypeApplications, TypeFamilies, ViewPatterns             #-}

import           Control.Applicative
import           Control.Exception
import           Control.Monad
import           Control.Monad.Primitive
import           Control.Monad.ST
import           Control.Monad.State.Strict
import           Data.Bool
import qualified Data.ByteString             as B
import qualified Data.ByteString.Builder     as B
import qualified Data.ByteString.Char8       as C
import qualified Data.ByteString.Internal    as B
import qualified Data.ByteString.Unsafe      as B
import           Data.Char
import qualified Data.Foldable               as F
import           Data.Function
import           Data.Functor.Identity
import qualified Data.IntMap.Strict          as IM
import qualified Data.IntSet                 as IS
import qualified Data.List                   as L
import qualified Data.Map.Strict             as M
import           Data.Monoid
import           Data.Ord
import           Data.Primitive
import           Data.Ratio
import qualified Data.Set                    as S
import           Data.Tuple
import qualified Data.Vector                 as V
import qualified Data.Vector.Generic         as G
import qualified Data.Vector.Generic.Mutable as GM
import qualified Data.Vector.Mutable         as VM
import qualified Data.Vector.Unboxed         as U
import qualified Data.Vector.Unboxed.Mutable as UM
import           Debug.Trace
import           Foreign                     hiding (void)
import           GHC.Exts
import qualified System.IO                   as IO
import           Unsafe.Coerce

main :: IO ()
main = do
    n <- readLn :: IO Int
    xs <- U.unfoldrN n (runParser int) <$> C.getLine
    print $ solve n xs

encode :: Int -> Int -> Word64
encode i x = unsafeCoerce $ unsafeShiftL (0x7fffffff - x) 32 .|. i

decode :: Word64 -> (Int, Int)
decode xi =
    let !x = 0x7fffffff - unsafeShiftR xi 32
        !i = xi .&. 0xffffffff
    in unsafeCoerce (i, x)

pre :: U.Vector Int -> U.Vector (Int, Int)
pre = U.map decode.radixSort64.U.imap encode

ix :: Int -> Int -> Int
ix i j = unsafeShiftL i 11 .|. j

solve :: Int -> U.Vector Int -> Int
solve n (pre -> xis) = runST $ do
    dp <- UM.replicate (2048 * 2048) 0
    rep n $ \i -> do
        rep (i + 1) $ \j -> do
            let l = j
            let r = i - j
            dpij <- UM.unsafeRead dp (ix l r)
            UM.unsafeModify dp (max (dpij + score i l))       (ix (l + 1) r)
            UM.unsafeModify dp (max (dpij + score i (n-1-r))) (ix l (r + 1))
    U.maximum <$> U.unsafeFreeze dp
  where
    score i pos = case U.unsafeIndex xis i of
        (o, x) -> x * abs (pos - o)

-------------------------------------------------------------------------------
-- Utils
-------------------------------------------------------------------------------
rep :: Monad m => Int -> (Int -> m ()) -> m ()
rep !n = U.forM_ $ U.generate n id
{-# INLINE rep #-}
rev :: Monad m => Int -> (Int -> m ()) -> m ()
rev !n = U.forM_ $ U.iterateN n (subtract 1) (n - 1)
{-# INLINE rev #-}
infixl 8 `shiftRL`, `unsafeShiftRL`
shiftRL = unsafeShiftRL
{-# INLINE shiftRL #-}
unsafeShiftRL (I# x#) (I# i#) = I# (uncheckedIShiftRL# x# i#)
{-# INLINE unsafeShiftRL #-}
type Parser a = StateT C.ByteString Maybe a
runParser :: Parser a -> C.ByteString -> Maybe (a, C.ByteString)
runParser = runStateT
{-# INLINE runParser #-}
int :: Parser Int
int = coerce $ C.readInt . C.dropWhile isSpace
{-# INLINE int #-}
int1 :: Parser Int
int1 = fmap (subtract 1) int
{-# INLINE int1 #-}
char :: Parser Char
char = coerce C.uncons
{-# INLINE char #-}
byte :: Parser Word8
byte = coerce B.uncons
{-# INLINE byte #-}
-------------------------------------------------------------------------------
-- Data.Vector.Sort.Radix
-------------------------------------------------------------------------------
radixSortInt :: U.Vector Int -> U.Vector Int
radixSortInt = unsafeCoerce . radixSort64 . unsafeCoerce
radixSort32 :: U.Vector Word32 -> U.Vector Word32
radixSort32 v = F.foldl' step v [0, 16] where { mask k x = fromIntegral $ unsafeShiftR x k .&. 65535; step v k = U.create $ do { pref <- U.unsafeThaw . U.prescanl' (+) 0 . U.unsafeAccumulate (+) (U.replicate 65536 0) $ U.map (flip (,) 1 . mask k) v; res <- UM.unsafeNew $ U.length v; U.forM_ v $ \ x -> do { let { !masked = mask k x}; i <- UM.unsafeRead pref masked; UM.unsafeWrite pref masked $ i + 1; UM.unsafeWrite res i x}; return res}}
{-# INLINE radixSort32 #-}
radixSort64 :: U.Vector Word64 -> U.Vector Word64
radixSort64 v = F.foldl' step v [0, 16, 32, 48] where { mask k x = fromIntegral $ unsafeShiftR x k .&. 65535; step v k = U.create $ do { pref <- U.unsafeThaw . U.prescanl' (+) 0 . U.unsafeAccumulate (+) (U.replicate 65536 0) $ U.map (flip (,) 1 . mask k) v; res <- UM.unsafeNew $ U.length v; U.forM_ v $ \ x -> do { let { !masked = mask k x}; i <- UM.unsafeRead pref masked; UM.unsafeWrite pref masked $ i + 1; UM.unsafeWrite res i x}; return res}}
{-# INLINE radixSort64 #-}