Problem:
Score : 400 points

Problem Statement

One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend.

Find the following:

Constraints

1 ≦ N ≦ 200,000

(a_1, a_2, ..., a_N) is a permutation of (1, 2, ..., N).

Input

The input is given from Standard Input in the following format:

N
a_1 a_2 ... a_N

Output

Print the answer.

Note that the answer may not fit into a 32-bit integer.

Sample Input 1

3
2 1 3

Sample Output 1

9

Sample Input 2

4
1 3 2 4

Sample Output 2

19

Sample Input 3

8
5 4 8 1 2 6 7 3

Sample Output 3

85

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

/*input
8
5 4 8 1 2 6 7 3

*/
#include <bits/stdc++.h>
#include <stdio.h>    
#include <string.h>
using namespace std;
#define mod 1000000007
 
#define llu long long unsigned
#define lld long long
#define ld long
#define sc(a) scanf("%lld",&a)
#define sc2(a,b) scanf("%lld%lld",&a,&b)
#define sc3(a,b,c) scanf("%lld%lld%lld",&a,&b,&c)
#define scf(a) scanf("%lf",&a)
#define scf2(a,b) scanf("%lf%lf",&a,&b)
#define scf3(a,b,c) scanf("%lf%lf%lf",&a,&b,&c)
#define prL(a) printf("%lld\n",a)
#define prS(a) printf("%lld ",a)
#define prfL(a) printf("%lf\n",a)
#define prfS(a) printf("%lf ",a) 
// #define swap(a,b,t) t=a;a=b;b=t
#define PA pair <lld,pair<lld,lld> >
 
#define lim 1000003
#define lim2 1005
lld A[lim],C[lim],nextP[lim],prevP[lim],D[lim];
typedef struct node{
    long long val;
    long long p;
}nody;
 
bool comp(nody i,nody j) {
    return i.val<j.val; 
}
nody N[lim];
 
// lld bina1(lld A[],lld k,lld low,lld high){
//     lld mid;
//     while(low<=high){
//         mid=low+(high-low)/2;
//         if(A[mid]==k){
//             if(mid==0) return C[0];
//             else return C[mid]-C[mid-1];
//         }
//         else if(A[mid]>k) high=mid-1;
//         else low=mid+1;
//     }
//     return 0;
// }
 
// lld bina2(lld A[],lld k,lld low,lld high){
//     lld mid;
//     while(high-low>1){
//         mid=low+(high-low)/2;
//         if(A[mid]<k) low=mid;
//         else high=mid-1;
//     }
//     if(A[high]<k) return C[high];
//     else if(A[low]<k) return C[low];
//     else return 0;
// }
 
// lld bina3(lld A[],lld k,lld low,lld high){
//     lld mid;
//     while(high-low>1){
//         mid=low+(high-low)/2;
//         if(A[mid]>k) high=mid;
//         else low=mid+1;
//     }
//     if(A[low]>k) return D[low];
//     else if(A[high]>k) return D[high];
//     else return 0;
// }
 
int main(){
    lld t,T,i,h,k,j,pos,ans,count,sum,m,q,r,n,p,a,b;
    sc(n);
    for(i=0;i<n;i++){
    	sc(A[i]);
    	A[i]=-A[i];
    }
    stack<pair<lld,lld> > S;
    pair<lld,lld> P;
    S.push(make_pair(A[0],0));
    for(i=1;i<n;i++){
        if(S.empty()){
            S.push(make_pair(A[i],i));
            continue;
        }
        P=S.top();
        if(P.first>A[i]) S.push(make_pair(A[i],i));
        else{
            nextP[P.second]=i;
            S.pop();
            i--;
        }
    }
    while(!S.empty()){
        P=S.top();
        nextP[P.second]=n;
        S.pop();
    }
    S.push(make_pair(A[n-1],n-1));
    for(i=n-2;i>=0;i--){
        if(S.empty()){
            S.push(make_pair(A[i],i));
            continue;
        }
        P=S.top();
        if(P.first>=A[i]) S.push(make_pair(A[i],i));
        else{
            prevP[P.second]=i;
            S.pop();
            i++;
        }
    }
    while(!S.empty()){
        P=S.top();
        prevP[P.second]=-1;
        S.pop();
    }
   	ans=0;
   	for(i=0;i<n;i++){
   		lld a,b;
   		// if(prevP[i]==-1) a=i;
   		// else a=i-prevP[i];
   		// if(nextP[i]==n) b=n-1-i;
   		// else b=nextP[i]-i+1;
   		ans+=-A[i]*(nextP[i]-i)*(i-prevP[i]);
   		// ans+=-A[i]*a*b;
   		// printf("ans=%lld i=%lld prevP=%lld nextP=%lld\n",ans,i,a,b );
   	}
   	prL(ans);
    // for(i=0;i<n;i++){
    //     N[i].val=A[i];
    //     N[i].p=(nextP[i]-i)*(i-prevP[i]);
    // }
    // sort(N,N+n,comp);
    // A[0]=N[0].val;
    // C[0]=N[0].p;
    // k=1;
    // for(i=1;i<n;i++){
    //     if(N[i].val!=N[i-1].val){
    //         A[k]=N[i].val;
    //         C[k]=N[i].p;
    //         k++;
    //     }
    //     else C[k-1]+=N[i].p;
    // }
    // for(i=0;i<k;i++) D[i]=C[i];
    // for(i=1;i<k;i++) C[i]=C[i]+C[i-1];
    // for(i=k-2;i>=0;i--) D[i]=D[i]+D[i+1];
    // // printf("%lld\n", k);
    // // for(i=0;i<k;i++) printf("%lld %lld\n",A[i],C[i]);
    // char play,rule,c1;
    // lld moveP;
    // scanf("%c",&c1);
    // while(m--){
    //     scanf("%c%lld\n",&play,&moveP );
    //     if(play=='='){
    //         ans=bina1(A,moveP,0,k-1);
    //         // printf("%lld(%c)\n", ans,play);
    //     }
    //     else if(play=='>'){
    //         ans=bina3(A,moveP,0,k-1);
    //         // printf("%lld(%c)\n", ans,play);
    //     }
    //     else{
    //         ans=bina2(A,moveP,0,k-1);
    //         // printf("%lld(%c)\n", ans,play);
    //     }
    //     scanf("%c\n",&rule );
    //     // printf("\n%c[%c]\n",play,rule );
    //     if(ans%2==0) printf("%c",'C'+'D'-rule);
    //     else printf("%c",rule );
    // }
    return 0;
}