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: Wrong Answer)

use std::io::{self, BufRead};

fn abs_sub(x: usize, y: usize) -> usize {
  if x < y { y - x } else { x - y }
}

fn process(xs: &Vec<usize>, moved: &Vec<bool>, mut lo: usize, mut hi: usize) -> usize {
  let mut result = 0;
  let mut moved = moved.clone();
  while lo < hi {
    let mut ys: Vec<_> = (0..moved.len()).filter(|y| !moved[*y]).map(|y| {
      let hi_val = abs_sub(hi - 1, y) * xs[y];
      let lo_val = abs_sub(lo, y) * xs[y];
      if lo_val < hi_val {
        (hi_val, y, true)
      } else {
        (lo_val, y, false)
      }
    }).collect();
    ys.sort_by(|t1, t2| t2.0.cmp(&t1.0));
    let (max_val, y, is_hi) = ys[0];
    let max_tups: Vec<_> = ys.iter().take_while(|t| t.0 == max_val).collect();
    if max_tups.len() == 1 {
      moved[y] = true;
      result += max_val;
      if is_hi {
        hi -= 1;
      } else {
        lo += 1;
      }
    } else {
      let rest_result = max_tups.iter().map(|(_, y, is_hi)| {
        let mut moved = moved.clone();
        moved[*y] = true;
        if *is_hi {
          process(&xs, &moved, lo, hi - 1)
        } else {
          process(&xs, &moved, lo + 1, hi)
        }
      }).max().unwrap();
      return result + max_val + rest_result;
    }
  }
  result
}

fn main() {
  let stdin = io::stdin();
  let mut lines = stdin.lock().lines();
  let _ = lines.next();
  let xs: Vec<usize> = lines.next().unwrap().unwrap().split(' ').map(|x| x.parse().unwrap()).collect();
  let moved = vec![false; xs.len()];
  let ans = process(&xs, &moved, 0, xs.len());
  println!("{}", ans);
}