Give you an array A[1..n] of length n .

Let f(l,r,k) be the k-th largest element of A[l..r].

Specially , f(l,r,k)=0 if r−l+1< k

Give you k , you need to calculate ∑(l =1 to n)∑(r = l to n)f(l,r,k)

There are T test cases.

1≤T≤10

k≤min(n,80)

A[1..n] is a permutation of [1..n]

∑n≤5∗100000

Input

There is only one integer T on first line.

For each test case,there are only two integers n , k on first line,and the second line consists

of nn integers which means the array A[1..n]

Output

For each test case,output an integer, which means the answer.

Sample Input

1

5 2

1 2 3 4 5

Sample Output

30

題意：

給我們一個數組 a [ ]，給了我們一個區間，兩層迴圈for(l=1 to n) for(r = l to n) 求區間 [ r , l ] 內第K大的數，把這些第K大的數累計求和。

解題思路：

採用列舉的思想，在 a 陣列中遍歷每一個元素，並求出該元素左右方各有多少個比它大的數，這樣我們就可以知道該元素可以在多少個區間內充當第K大的數。

PS:該演算法是暴力列舉，所以最終程式碼是卡時間過的，大約1800ms左右，有可能超時，所以如果超時了可以換個姿勢再來一遍 orz

詳解：

舉個例子，例如上圖，此時遍歷到 9

那麼我們在它的左邊取兩個比它大的數，右邊不取，可以發現區間 [ 2，9 ]中，9 號點位於第三大，所以這區間是符合條件的，然後我們把區間的邊界進行平移一下，可以發現在 [ 1 , 9 ] 中也可以滿足，最終可以發現左邊界可以用 ( 1 ， 2 ) ，右邊界可以用( 9 ， 10 )，所以這種情況下可以組成 number( 1 ， 2 ) * number( 9，10 ) =4 種區間。

然後找下一種情況，它的左邊取一個比它大的數，右邊再取一個比它大的數，於是發現區間[ 5,11 ]符合條件，同理，我們對區間邊界進行一下擴充套件，發現左邊界可以用( 3 ， 4 ， 5 )，右邊界可以用( 11 ， 12 ， 13 ， 14 )，所以這種情況可以組成 number( 3，4，5 ) * number( 11，12，13，14 ) =12種區間。

然後繼續找下一種情況，左邊不放比它大的數，右邊放兩個比它大的數，可以發現區間 [ 9，15 ]是符合條件的，擴充套件一下區間邊界，左邊界可以用 ( 6 ，7 ，8 ) ，右邊界可以用( 15，16 ，17 )，所以這種情況下可以組成 number ( 6 ，7 ，8 ) * number( 15，16 ，17 ) =9 種區間。

所以這個 9 號元素就遍歷完了，以 9 號元素為第三大的數的區間一共有 4+12+9=25 種，每次 9 號元素都會加一次，所以 9 號元素對總和的貢獻是 a[ 9 ] * 25 。然後繼續遍歷下一個元素即可，當所有元素遍歷完，總和就求出來了。

程式碼：

#include<cstdio>
#include<cstring>
using namespace std;
const int Max = 5*10e5+10;
int a[Max],r[Max],l[Max];   ///r[x]用來存該元素右邊第x個比它大的數與該元素的距離，l[x]同理
int rcnt,lcnt；             ///rcnt用來標記該元素右邊有多少個比該元素大的數，rcnt同理
int rnum,lnum;             ///rnum表示初始右邊界的右邊有多少個可以擴充套件的點，lrum同理
long long ans;
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,k;
        scanf("%d%d",&n,&k);
        for(int i=0; i<n; i++)
        {
            scanf("%d",&a[i]);
        }
        ans=0;
        for(int i=0; i<n; i++)
        {
            rcnt=lcnt=1;
            int j;
            for(j=i+1; j<n; j++)
            {
                if(rcnt>k)
                    break;
                if(a[j]>a[i])
                    r[rcnt++]=j-i;
            }
            if(j>=n)
                r[rcnt]=n-i;
            ///---------------左右方向分界線--------------///
            for(j=i-1; j>=0; j--)
            {
                if(lcnt>k)
                    break;
                if(a[j]>a[i])
                    l[lcnt++]=i-j;
            }
            if(j<0)
                l[lcnt]=i-(-1);
            if(lcnt+rcnt-2+1<k)
                continue;
            else
            {
                for(int x=0; x<lcnt; x++)
                {
                    if(x+rcnt-1+1<k)
                        continue;
                    else
                    {
                        lnum=l[x+1]-l[x];
                        rnum=r[k-x]-r[k-x-1];
                        ans+=(long long)a[i]*lnum*rnum;
                    }
                }
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}