HDU-6058 Kanade's sum

2017 Multi-University Training Contest - Team 3 - 1003

HDU-6058 Kanade’s sum

题意：

给一个数组A，然后求每个小区间 [l, r] 中第 k 大数的和，l 从 1 到 n，r 从 l 到 n，当区间里的数不够 k 个时第 k 大为 0 （$f(l,r,k)=0$ if $r−l+1<k$）

思路：

枚举 A 中每个数 $a_i$ 记录下 $a_i$ 前后比它大的 k 个数的坐标（这是为了求出 $a_i$ 为第 k 大数的区间个数），如果不够 k 个则前面的记为 -1 后面记为 n （emmm….这个怎么解释呢，自己理解理解吧）。然后坐标做差相乘再就是 $a_i$ 为第 k 大数的区间个数，再乘 $a_i$ 就可以了。具体的我下面举个栗子，通过栗子理解一下吧。
但这样做基本上是卡时间过的。题解说的用链表实现，整体的思路没变，还是记录下 $a_i$ 前后比它大的 k 个数的坐标，只不过 $a_i$ 不是从 A 的第一个到最后一个，是按顺序从 1 到 n 枚举，每个 $a_i$ 用完就从链表中删除，这样当找比 $a_{i + 1}$ 大的数的时候就会快（因为比它小的都已经删除了）。

栗子：

n = 11， k = 3， $a_i$ = 7

坐标： 0    1     2    3     4    5    6    7     8    9       10
数值： 2， 3， 8， 1， 7， 4， 5， 9， 6， 10 ， 11

$a_i$ 前面比它大的 k 个数的坐标： l = 4， 2， -1 （$l_{[0]}$ = 4 为 $a_i$ 所在的坐标）
$a_i$ 后面比它大的 k 个数的坐标： r = 4， 7， 9， 10（$r_{[0]}$ = 4 为 $a_i$ 所在的坐标）
则（…8， …7， …9，…）这样的区间有 （2 - （-1）） * （9 - 7） = 6 个，
则（…7， …9，…10，…）这样的区间有 （4 - 2） * （10 - 9） = 2 个。
所以 ans += （6 + 2） * 7

代码：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
const int maxx = 5e5 + 10;

int a[maxx], l[105], r[105];
int main()
{
    int t, n, k;
    int lnum, rnum;
    long long ans;
    while(~scanf("%d", &t))
    {
        while(t--)
        {
            memset(a, 0, sizeof(a));
            memset(l, 0, sizeof(l));
            memset(r, 0, sizeof(r));
            ans = 0;
            scanf("%d%d", &n, &k);
            for(int i = 0; i < n; ++i)
            {
                scanf("%d", &a[i]);
            }
            for(int i = 0; i < n; ++i)
            {
                lnum = rnum = 1;
                r[0] = l[0] = i;
                int j;

                for(j = i + 1; j < n; ++j)
                {
                    if(a[j] > a[i])
                    {
                        r[rnum++] = j;
                    }
                    if(rnum > k)
                    {
                        break;
                    }
                }
                if(rnum == k + 1)
                {
                    --rnum;
                }
                if(j >= n)
                {
                    r[rnum] = n;
                }

                for(j = i - 1; j >= 0; --j)
                {
                    if(a[j] > a[i])
                    {
                        l[lnum++] = j;
                    }
                    if(lnum > k)
                    {
                        break;
                    }
                }
                if(lnum == k + 1)
                {
                    --lnum;
                }
                if(j < 0)
                {
                    l[lnum] = -1;
                }

                for(int j = 1; j <= rnum; ++j)
                {
                    if(k - j  + 1 == lnum)
                    {
                        ans += (long long)a[i] * (r[j] - r[j - 1]) * (l[lnum - 1] - l[lnum]);
                        --lnum;
                    }
                    if(!lnum)
                    {
                        break;
                    }
                }
            }
            cout << ans << endl;
        }
    }
    return 0;
}