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 Rust (1.42.0) (judge verdict: Accepted)

pub struct Scanner {
    line: Vec<String>,
    idx: usize,
}

#[allow(dead_code)]
impl Scanner {
    fn new() -> Scanner {
        return Scanner {
            line: vec![],
            idx: 0,
        };
    }
    fn next<T: std::str::FromStr>(&mut self) -> T {
        if self.idx == self.line.len() {
            let mut buffer = String::new();
            std::io::stdin().read_line(&mut buffer).ok();
            let a: Vec<&str> = buffer.trim().split(' ').collect();
            self.line = a.iter().map(|&s| String::from(s)).collect();
            self.idx = 0;
        }
        let ret: T = self.line[self.idx].parse::<T>().ok().expect("Parse error.");
        self.idx += 1;
        ret
    }
    fn next_string(&mut self) -> Vec<char> {
        let s: String = self.next();
        return s.chars().collect::<Vec<char>>();
    }
    fn next_vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        let mut v: Vec<T> = Vec::with_capacity(n);
        for _i in 0..n {
            v.push(self.next());
        }
        v
    }
}


fn main(){
    let mut scan = Scanner::new();
    let n: usize = scan.next();
    let a: Vec<i64> = scan.next_vec(n);

    let mut ord: Vec<(i64,usize)> = Vec::with_capacity(n);
    for i in 0..n {
        ord.push((a[i], i));
    }
    ord.sort_by_key(|x| -x.0);

    let mut dp: Vec<Vec<i64>> = vec![vec![-1; n+1]; n+1];
    dp[0][0] = 0;
    for i in 0..n {
        for j in 0..n {
            if dp[i][j] < 0 {
                continue;
            }
            let (a, idx) = ord[i];
            dp[i+1][j+1] = std::cmp::max(dp[i+1][j+1], dp[i][j] + a* (j as i64 - idx as i64).abs());
            dp[i+1][j] = std::cmp::max(dp[i+1][j], dp[i][j] + a* ((n - 1 - (i - j)) as i64 - idx as i64).abs());
        }
    }
    
    println!("{}", dp[n].iter().fold(0, |sum, x| std::cmp::max(sum, *x)) );
}