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)

// This code is generated by [cargo-atcoder](https://github.com/tanakh/cargo-atcoder)
// Original source code:
/*
use competitive::prelude::*;
use rand::prelude::*;
use std::thread;

#[derive(Clone)]
pub struct AnnealingOptions {
    pub steps: usize,
    pub limit_temp: f64,
    pub restart: usize,
    pub threads: usize,
    pub silent: bool,
}

pub trait Annealer {
    type State: Clone + Send + Sync;
    type Move;

    fn init_state(&self, rng: &mut impl Rng) -> Self::State;
    fn start_temp(&self, init_score: f64) -> f64;

    fn is_done(&self, _score: f64) -> bool {
        false
    }

    fn eval(&self, state: &Self::State) -> f64;

    fn neighbour(&self, state: &Self::State, rng: &mut impl Rng) -> Self::Move;

    fn apply(&self, state: &mut Self::State, mov: &Self::Move);
    fn unapply(&self, state: &mut Self::State, mov: &Self::Move);

    fn apply_and_eval(&self, state: &mut Self::State, mov: &Self::Move, _prev_score: f64) -> f64 {
        self.apply(state, mov);
        self.eval(state)
    }
}

pub fn annealing<A: 'static + Annealer + Clone + Send>(
    annealer: &A,
    opt: &AnnealingOptions,
    seed: u64,
) -> (f64, <A as Annealer>::State) {
    assert!(opt.threads > 0);

    if opt.threads == 1 {
        do_annealing(None, annealer, opt, seed)
    } else {
        let mut ths = vec![];
        let mut rng = StdRng::seed_from_u64(seed);

        for i in 0..opt.threads {
            let a = annealer.clone();
            let o = opt.clone();
            let tl_seed = rng.gen();
            ths.push(thread::spawn(move || {
                do_annealing(Some(i), &a, &o, tl_seed)
            }));
        }

        ths.into_iter()
            .map(|th| th.join().unwrap())
            .min_by(|a, b| a.0.partial_cmp(&b.0).unwrap())
            .unwrap()
    }
}

fn do_annealing<A: Annealer>(
    thread_id: Option<usize>,
    annealer: &A,
    opt: &AnnealingOptions,
    seed: u64,
) -> (f64, <A as Annealer>::State) {
    let mut rng = SmallRng::seed_from_u64(seed);

    let mut state = annealer.init_state(&mut rng);
    let mut cur_score = annealer.eval(&state);
    let mut best_score = cur_score;
    let mut best_ans = state.clone();

    macro_rules! progress {
        ($($arg:expr),*) => {
            if !opt.silent {
                if let Some(tid) = thread_id {
                    eprint!("[{:02}] ", tid);
                }
                eprintln!($($arg),*);
            }
        };
    }

    progress!("Initial score: {}", cur_score);

    let mut restart_cnt = 0;

    let t_max = annealer.start_temp(cur_score);
    let t_min = opt.limit_temp;

    let step = opt.steps as f64;
    let decay = ((t_min / t_max).ln() / step).exp();

    progress!("Temperature decay: {}", decay);

    let mut temp = t_max;
    loop {
        if temp < t_min {
            restart_cnt += 1;
            if restart_cnt >= opt.restart {
                break;
            }
            progress!("Restarting... {}/{}", restart_cnt, opt.restart);
            temp = t_max;
        }

        let mov = annealer.neighbour(&state, &mut rng);
        let new_score = annealer.apply_and_eval(&mut state, &mov, cur_score);

        if new_score <= cur_score
            || rng.gen::<f64>() <= ((cur_score - new_score) as f64 / temp).exp()
        {
            cur_score = new_score;
            if cur_score < best_score {
                if best_score - cur_score > 1e-6 {
                    progress!("Best: score = {:.3}, temp = {:.9}", cur_score, temp);
                }
                best_score = cur_score;
                best_ans = state.clone();
            }
            if annealer.is_done(cur_score) {
                break;
            }
        } else {
            annealer.unapply(&mut state, &mov);
        }

        temp *= decay;
    }
    (best_score, best_ans)
}

#[derive(Clone)]
struct E {
    a: Vec<i64>,
}

impl Annealer for E {
    type State = Vec<usize>;
    type Move = (usize, usize);

    fn init_state(&self, _rng: &mut impl Rng) -> Self::State {
        (0..self.a.len()).collect_vec()
    }

    fn start_temp(&self, _init_score: f64) -> f64 {
        1e13
    }

    fn is_done(&self, _score: f64) -> bool {
        false
    }

    fn eval(&self, state: &Self::State) -> f64 {
        let mut ret = 0;
        for i in 0..self.a.len() {
            ret += self.a[i] * (i as i64 - state[i] as i64);
        }
        -ret as f64
    }

    fn neighbour(&self, _state: &Self::State, rng: &mut impl Rng) -> Self::Move {
        loop {
            let i = rng.gen_range(0, self.a.len());
            let j = rng.gen_range(0, self.a.len());
            if i != j {
                return (i, j);
            }
        }
    }

    fn apply(&self, state: &mut Self::State, mov: &Self::Move) {
        state.swap(mov.0, mov.1);
    }

    fn unapply(&self, state: &mut Self::State, mov: &Self::Move) {
        state.swap(mov.0, mov.1);
    }

    fn apply_and_eval(&self, state: &mut Self::State, mov: &Self::Move, prev_score: f64) -> f64 {
        let i = mov.0;
        let j = mov.1;
        let new_score = -prev_score
            - (self.a[i] * (i as i64 - state[i] as i64).abs()
                + self.a[j] * (j as i64 - state[j] as i64).abs()) as f64
            + (self.a[i] * (i as i64 - state[j] as i64).abs()
                + self.a[j] * (j as i64 - state[i] as i64).abs()) as f64;
        state.swap(mov.0, mov.1);
        -new_score
    }
}

fn main() {
    input! {
        n: usize,
        a: [i64; n],
    }

    let e = E { a: a.clone() };
    let r = annealing(
        &e,
        &AnnealingOptions {
            steps: 10_000_000,
            limit_temp: 0.1,
            restart: 1,
            threads: 1,
            silent: true,
        },
        777,
    );

    let mut ans = 0;
    let alloc = r.1;

    for i in 0..n {
        ans += a[i] * (i as i64 - alloc[i] as i64).abs();
    }

    echo!(ans);
}
*/

fn main() {
    let exe = "/tmp/binE79180F9";
    std::io::Write::write_all(&mut std::fs::File::create(exe).unwrap(), &decode(BIN)).unwrap();
    std::fs::set_permissions(exe, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    std::process::exit(std::process::Command::new(exe).status().unwrap().code().unwrap())
}

fn decode(v: &str) -> Vec<u8> {
    let mut ret = vec![];
    let mut buf = 0;
    let mut tbl = vec![64; 256];
    for i in 0..64 { tbl[TBL[i] as usize] = i as u8; }
    for (i, c) in v.bytes().filter_map(|c| { let c = tbl[c as usize]; if c < 64 { Some(c) } else { None } }).enumerate() {
        match i % 4 {
            0 => buf = c << 2,
            1 => { ret.push(buf | c >> 4); buf = c << 4; }
            2 => { ret.push(buf | c >> 2); buf = c << 6; }
            3 => ret.push(buf | c),
            _ => unreachable!(),
        }
    }
    ret
}

const TBL: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const BIN: &'static str = "<base64-encoded ELF executable removed>";