Problem:
Score: 500 points

Problem Statement

Given is a permutation P of \{1, 2, \ldots, N\}.

For a pair (L, R) (1 \le L \lt R \le N), let X_{L, R} be the second largest value among P_L, P_{L+1}, \ldots, P_R.

Find \displaystyle \sum_{L=1}^{N-1} \sum_{R=L+1}^{N} X_{L,R}.

Constraints

2 \le N \le 10^5

1 \le P_i \le N

P_i \neq P_j (i \neq j)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
P_1 P_2 \ldots P_N

Output

Print \displaystyle \sum_{L=1}^{N-1} \sum_{R=L+1}^{N} X_{L,R}.

Sample Input 1

3
2 3 1

Sample Output 1

5

X_{1, 2} = 2, X_{1, 3} = 2, and X_{2, 3} = 1, so the sum is 2 + 2 + 1 = 5.

Sample Input 2

5
1 2 3 4 5

Sample Output 2

30

Sample Input 3

8
8 2 7 3 4 5 6 1

Sample Output 3

136

Solution in Rust (1.42.0) (judge verdict: Accepted)

#[allow(unused_imports)]
use itertools::Itertools;
#[allow(unused_imports)]
use num::*;
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;
#[allow(unused_imports)]
use std::collections::*;

#[allow(non_snake_case)] // for `input! { N: ... }`
fn solve() {
    input! {
        N: usize,
        P: [usize; N]
    };

    let mut indexes = vec![0; N + 1];
    for (i, &p) in P.iter().enumerate() {
        indexes[p] = i;
    }
    let mut set: BTreeSet<usize> = BTreeSet::new();
    set.insert(indexes[N]);
    let mut res = 0_usize;
    for n in (1..N).rev() {
        let i = indexes[n];
        let mut iter = set.range(0..i);
        let l1 = iter.next_back();
        let l2 = iter.next_back();
        let mut iter = set.range(i + 1..);
        let r1 = iter.next();
        let r2 = iter.next();
        res += match (l2, l1, r1) {
            (None, Some(l1), None) => (l1 + 1) * (N - i) * n,
            (None, Some(l1), Some(r1)) => (l1 + 1) * (r1 - i) * n,
            (Some(l2), Some(l1), None) => (l1 - l2) * (N - i) * n,
            (Some(l2), Some(l1), Some(r1)) => (l1 - l2) * (r1 - i) * n,
            _ => 0,
        };
        res += match (l1, r1, r2) {
            (None, Some(r1), None) => (i + 1) * (N - r1) * n,
            (None, Some(r1), Some(r2)) => (i + 1) * (r2 - r1) * n,
            (Some(l1), Some(r1), None) => (i - l1) * (N - r1) * n,
            (Some(l1), Some(r1), Some(r2)) => (i - l1) * (r2 - r1) * n,
            _ => 0,
        };
        set.insert(i);
    }
    println!("{}", res);
}

fn main() {
    std::thread::Builder::new()
        .name("big stack size".into())
        .stack_size(256 * 1024 * 1024)
        .spawn(|| {
            solve();
        })
        .unwrap()
        .join()
        .unwrap();
}