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.15.1) (judge verdict: Time Limit Exceeded)

fn input_t<T: std::str::FromStr>() -> T {
	let mut s = String::new();
	std::io::stdin().read_line(&mut s).unwrap();
	s.trim().parse().ok().unwrap()
}
 
fn input_vt<T: std::str::FromStr>() -> Vec<T> {
	let mut s = String::new();
	std::io::stdin().read_line(&mut s).unwrap();
	s.trim().split_whitespace().map(|x| x.parse().ok().unwrap()).collect()
}

fn main() {
	use std::iter::Iterator;
    
	let     n  = input_t::<usize>();
    let     ps = input_vt::<u64>();
    let mut bt = std::collections::BTreeSet::new();
    let mut a  = 0;
    
    for x in ps.iter() {
    	bt.insert(*x);
    }
    
    for i in 0..(n - 1) {
    	let     x  = *bt.iter().rev().nth(1).unwrap();
        let mut y1 = ps[i];
        let mut y2 = 0;
        
        for j in (i + 1)..n {
            y2 = std::cmp::max(y2, std::cmp::min(y1, ps[j]));
        	y1 = std::cmp::max(y1, ps[j]);
            
            if y2 == x {
            	a += y2 * ((n - j) as u64);
                break;
            } else {
            	a += y2;
            }
        }
        
        bt.remove(&ps[i]);
    }
    
    println!("{}", a);
}