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 C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using static System.Math;
using static System.Array;
using static AtCoder.Tool;
namespace AtCoder
{
    class AC
    {
        const int MOD = 1000000007;
        const int INF = int.MaxValue / 2;
        const long SINF = long.MaxValue / 2;
        const double EPS = 1e-8;
        static readonly int[] dx = { 0, 1, 0, -1 };
        static readonly int[] dy = { 1, 0, -1, 0 };
        //static List<List<int>> G = new List<List<int>>();
        //static List<List<Edge>>G = new List<List<Edge>>();
        //static List<Edge> E = new List<Edge>();


        static void Main(string[] args)
        {
            //var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            //Console.SetOut(sw);
            var cin = new Scanner();

            int N = int.Parse(Console.ReadLine());
            var P = cin.ReadSplit();
            var sg = new SegmentTree<Pair<int, int>>(N, f, new Pair<int, int>(-1, -1));
            sg.Set_All();
            var ind = new int[N];
            for (var i = 0; i < N; i++) ind[P[i] - 1] = i;
            long ans = 0;
            for(var i = N; i >= 1; i--)
            {
                int k = ind[i - 1];
                int a, d;
                sg.Query_Update(k, new Pair<int, int>(k, k));
                int b = sg.Query_Answer(0, k).first;
                if (b > 0) { a = sg.Query_Answer(0, b).first; }
                else { a = -1; }

                int c = sg.Query_Answer(k + 1, N).second;
                if (c != -1 && c < N - 1) { d = sg.Query_Answer(c + 1, N).second; }
                else { d = N; }
                if (c == -1) { c = N; }
                if (d == -1) { d = N; }
                //Console.WriteLine($"{i} {a} {b} {c} {d} : {i * ((b - a) * (c - k) + (d - c) * (k - b))}");//
                ans += i * ((b - a) * (c - k) + (d - c) * (k - b));
            }

            Console.WriteLine(ans);


            //Console.Out.Flush();
        }
        static Pair<int, int> f(Pair<int, int> p1, Pair<int, int> p2)
        {
            int retmax = Max(p1.first, p2.first);
            int retmin;
            if (p1.second > 0 && p2.second > 0) { retmin = Min(p1.second, p2.second); }
            else { retmin = Max(p1.second, p2.second); }

            return new Pair<int, int>(retmax, retmin);
        }
        struct Edge
        {
            public int from;

            public int to;
            public long dist;
            public Edge(int t, long c)
            {
                from = -1;
                to = t;
                dist = c;
            }
            public Edge(int f, int t, long c)
            {
                from = f;
                to = t;
                dist = c;
            }

        }
    }
    struct Pair<T, U> : IComparable<Pair<T, U>>
       where T : IComparable<T>
       where U : IComparable<U>
    {
        public T first;
        public U second;
        private bool CompWithFirst;

        public Pair(T f, U s, int comp)
        {
            first = f;
            second = s;
            CompWithFirst = comp == 1;
        }
        public Pair(T f, U s)
        {
            first = f;
            second = s;
            CompWithFirst = true;
        }

        public int CompareTo(Pair<T, U> other)
        {
            return CompWithFirst ? first.CompareTo(other.first) : second.CompareTo(other.second);
        }
    }
    public class SegmentTree<T>
    {
        int n;
        T[] Tree;
        Func<T, T, T> f;
        T ex;
        public SegmentTree(int size, Func<T, T, T> fun, T exvalue)
        {
            f = fun;
            ex = exvalue;
            n = 1;
            while (n < size) n <<= 1;
            Tree = new T[(n << 1) - 1];
            for (var i = 0; i < Tree.Length; i++) Tree[i] = ex;
        }
        public SegmentTree(int size, Func<T, T, T> f, T exvalue, T initial) : this(size, f, exvalue)
        {
            for (var i = 0; i < size; i++) Tree[i + n - 1] = initial;
            Set_All();
        }

        public void Set_All()
        {
            for (var i = n - 2; i >= 0; i--)
            {
                Tree[i] = f(Tree[(i << 1) + 1], Tree[(i << 1) + 2]);
            }
        }

        public void Assign(int ind, T val)
        {
            Tree[ind + n - 1] = val;
        }
        public void Update(int ind)
        {
            int i = ind + n - 1;
            while (i > 0)
            {
                i = (i - 1) >> 1;
                Tree[i] = f(Tree[(i << 1) + 1], Tree[(i << 1) + 2]);
            }
        }

        public void Query_Update(int ind, T val)
        {
            Assign(ind, val);
            Update(ind);
        }
        public T Query_Answer(int l, int r) //[l,r)
        {
            return Scanning(l, r, 0, 0, n);
        }
        private T Scanning(int l, int r, int ind, int ind_l, int ind_r)
        {
            if (ind_r <= l || r <= ind_l) { return ex; }
            if (l <= ind_l && ind_r <= r) { return Tree[ind]; }
            return f(Scanning(l, r, (ind << 1) + 1, ind_l, (ind_l + ind_r) >> 1), Scanning(l, r, (ind << 1) + 2, (ind_l + ind_r) >> 1, ind_r));
        }

        public T Look(int ind)
        {
            return Tree[ind + n - 1];
        }
        public void Debug_Display_All()
        {
            for (var i = 0; i < n; i++) Console.Write($"{Tree[i + n - 1]} ");
            Console.WriteLine();
        }
    }
    public class Scanner
    {
        public int[] ReadSplit()
        {
            return ConvertAll(Console.ReadLine().Split(), int.Parse);
        }
        public long[] ReadSplitL()
        {
            return ConvertAll(Console.ReadLine().Split(), long.Parse);
        }
        public double[] ReadSplitD()
        {
            return ConvertAll(Console.ReadLine().Split(), double.Parse);
        }
    }
    public static class Tool
    {
        static public void Initialize<T>(ref T[] array, T initialvalue)
        {
            for (var i = 0; i < array.Length; i++)
            {
                array[i] = initialvalue;
            }
        }
        static public void Swap<T>(ref T a, ref T b)
        {
            T keep = a;
            a = b;
            b = keep;
        }

        static public void Display<T>(T[,] array2d, int n, int m)
        {
            for (var i = 0; i < n; i++)
            {
                for (var j = 0; j < m; j++)
                {
                    Console.Write($"{array2d[i, j]} ");
                }
                Console.WriteLine();
            }
        }

    }
}