Kanade's sum HDU - 6058

            Kanade's sum

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 ∑nl=1∑nr=lf(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∗105

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 n 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

题目大意：把一个数组分成若干子部分，求每部分中第k大的数的和胃多少？

解题思路：首先能够想到的暴力算法是：枚举数组的每一个子部分(二重for循环)，然后求出每一段的第k大的数又是一层for循环，这样时间复杂度为O(n^3).  看一下数据就知道这样的做法肯定是不行的。

               然后我们能想到的是对于数组中的数x，我们只要找到x的左边有k个比x大的数的位置，然后在右边找出k个比x大的数就行了。

              首先暴力去找左边和右边的数(看脸AC)。我们可以通过set容器自动排序这一特性，实现这一想法。我们知道x的左边就意味着它的下标是比x的下标小，同理，x的右边就意味着它的下标是比x的下标大，所以我们只要把x的下标放入set中就可以了。然后我们在找x的左边时要求每一次都能够找到下一个比当前x大的值。这样就需要用数组来存储它的左边和右边的下一个比它大的位置。最后我们在左边统计出k个位置对应着右边的k个位置，计算他们的位置差的乘积就可以了。

AC代码：

#include<iostream>
#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+5;
int vis[maxn],left1[maxn],right1[maxn],nowl,nowr,nextl,nextr,l,r;
int main()
{
    int t,n,k;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&k);
        int x;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&x);
            vis[x]=i;   ///(1)处理数据 (2)方便索引，记录数据的位置，要找x的位置的话，直接vis[x];
            left1[i]=0;///0和n+1都是不存在的
            right1[i]=n+1;
        }
        set<int>s;
        set<int>::iterator it;
        left1[n+1]=0;
        right1[n+1]=n+1;
        s.insert(0);///所有的位置在(0,n+1)之间
        s.insert(n+1);///默认第一个位置和最后一个位置上是最大值

        long long ans=0;
        for(int i=n;i>0;i--)
        {
            s.insert(vis[i]);///由大到小插入x
            it=s.find(vis[i]);///插入的x所在的位置
            it++;
            r=*it;
 ///插入一个数需要改变这个数的left1[]和right1[],以及与这个数相邻的right[]或left[]
            l=left1[r];///左边最靠近x的vis值

            left1[r]=vis[i];///右边的数改变left1[]
            right1[vis[i]]=r;
            right1[l]=vis[i];///左边的数改变right[]
            left1[vis[i]]=l;

            if(n-i+1<k)///n-i+1表示已经插入的元素的个数，好好体会下
                continue;

            nowl=vis[i];
            for(int j=0;j<k&&nowl!=0;j++)///左端找出k个比x大的数的位置，有可能不足k个
                nowl=left1[nowl];

            nowr=nowl;  ///从左端位置往右找，凑足k个数
            for(int j=0;j<k&&nowr!=n+1;j++)
                nowr=right1[nowr];

            for(int j=0;j<k;j++)
            {
                if(nowl==vis[i]||nowr==n+1)///k个数里面一定要包含x
                    break;               ///超过了x就可以跳出了

                nextl=right1[nowl];
                nextr=right1[nowr];///这个位置到下一个位置之间是可以任意选择的
                                   ///所以计算乘积好了
                ans+=(long long)(nextl-nowl)*(nextr-nowr)*i;
                nowl=nextl;
                nowr=nextr;
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}

解法二：模拟链表(j)

通过建立与链表类似的结构来存储数据，将数据存储在数组的下标，数组的值存储的是数据的位置，能实现这一思想的方法也是a[1]--a[n]之间的数值在1--n之间且无重复，我们通过链表从最小的数值开始向链表的两端找 可能使他成为第k大区间的范围。找完后删除这个值，再找下一个最小的值。

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
typedef long long LL;
const int K=1e6+7;
int n,k,p[K],pre[K],nxt[K],pos[K],tl[85],tr[85];
LL ans;
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        ans=0;
        scanf("%d%d",&n,&k);///读入n和k n为已知数的个数 k为公式条件
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&p[i]);///读入p数组
            pos[p[i]]=i;///将p数组的下标和数值互换 pos数组这里体现了模拟链表的思想 pos的下标为数 pos的值为这个数的位置
        }

        for(int i=1; i<=n; i++)
            pre[i]=i-1,nxt[i]=i+1;///对pre数组和nxt进行赋值 pre为下标-1，nxt为下标+1
        ///pre[1]=0,nxt[n]=n+1;///对两个数组的头和尾进行处理 防止越界

        for(int i=1; i<=n-k+1; i++) ///开始最外层的循环 i的值是开始输入时p【i】中的值 pos【i】是i这个值的位置
        {
            ///因为位置和数值都是从1到n的 找区间第k大的数 大于n-k+1的数不可能在任何区间成为第k大的数 直接让i<n-k+1就行
            int la=0,lb=0;
            for(int j=pos[i]; j>0&&la<=k; j=pre[j]) ///i这个数的位置向前推 找到能形成k大区间的前限可能位置个数
                tl[la++]=j-pre[j];
            for(int j=pos[i]; j<=n&&lb<=k; j=nxt[j]) ///i这个数的位置向后推 找到能形成k大区间的后限的可能位置的个数
                tr[lb++]=nxt[j]-j;
            for(int j=0; j<la; j++)
                if(k-j-1<lb)///判断这个位置是否越界
                    ans+=i*(1ll)*tl[j]*tr[k-j-1];///左边区间长度*右边区间长度就是这个可能区间个数的总量 再乘i值本身也就是答案了

            pre[nxt[pos[i]]]=pre[pos[i]];///重新更新去掉已被处理完i值之后前驱后继数组的值
            nxt[pre[pos[i]]]=nxt[pos[i]];
        }
        printf("%lld\n",ans);
    }
    return 0;
}