[COGS 2065]学数数

2065. 学数数

★★★☆   输入文件：jxthree.in   输出文件：jxthree.out   简单对比
时间限制：1 s   内存限制：256 MB

【题目描述】

 

从前有一只咩，还有一只叽，还有……嗯……一只毒。

毒是咩和叽的师父。

咩经常算不对像3+0.5这样的数，它总认为3+0.5=5。叽经常算不对60+20这样的数，它总认为60+20=100。

所以毒为了锻炼它们数数的能力，想出了下面这个游戏：

毒先在纸上写下n个数a1，a2，…，an，然后咩和叽会找出所有的连续子数组(共有n*(n+1)/2个)，在自己的纸上记录下每个连续子数组的最大值，那之后毒会给

咩和叽Q个问题，每个问题形如下面三种之一：

1．记录的数中有多少个大于K?

2．记录的数中有多少个等于K?

3．记录的数中有多少个小于K?

然而这只咩太蠢了，总是答错毒的问题，咩很伤心，请你帮帮它吧!

 

【输入格式】

 

第一行两个整数n，Q。

第二行n个整数a1，a2，…，an。

下面Q行，每行有一个字符op和一个整数K。

如果op是“>”，说明是第一种问题。

如果op是“=”，说明是第二种问题。

如果op是“<"，说明是第三种问题

 

【输出格式】

共有Q行，第i行表示第i个问题的答案。

【样例输入】

3  5

1  2  3

>  1

<  2

=  3

>  4

<  5

【样例输出】

5

1

3

0

6

【提示】

 

 咩和叽的纸上应该写着1，2，2，3，3，3。

  数据范围与约定

 对于20％的数据，1≤n≤200，1≤Q≤200，1≤ai，K≤10^6。

 对于40％的数据，1≤n≤5000，1≤Q≤5000，1≤ai，K≤10^6。

 对于60％的数据，1≤n≤10^5，1≤Q≤10^5，1≤ai，K≤10^6，ai两两不同。

 对于80％的数据，1≤n≤10^5，1≤Q≤10^5，1≤ai，K≤10^6。

 对于100％的数据，1≤n≤10^5，1≤Q≤10^5，1≤ai，K≤10^9。

题解

我们大概可以注意到, 以某个数为最大值的最大连续子数组的左右端点都会延伸到比该数大的第一个数的右/左边, 而连续子数组的个数就等于它向右延伸的个数乘以向左延伸的个数. 所以我们可以预处理出这个左右端点(或者左/右边第一个比它大的数的位置), 然后对它求前缀和, 按需响应查询就可以了

而至于左右端点的预处理, 我们首先对它进行离散化, 然后使用树状数组( $O(nlog(n))$ )或者单调栈( $O(n)$ )分别从两个方向扫描一遍来处理.

然后就是注意区间要左闭右开防止重复计数

参考代码

这里是单调栈的版本

GitHub

#include <stack>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

const int MAXN=100010;

int n;
int q;
int* sed;
int a[MAXN];
int b[MAXN];
int s[MAXN];
int l[MAXN];
int r[MAXN];
long long cnt[MAXN];

void Initialize();
template<class T> void Clear(T&);

int main(){
    Initialize();
    int tmp;
    char buf[5];
    for(int i=1;i<=n;i++){
        tmp=std::lower_bound(s+1,sed,a[i])-s;
        cnt[tmp]+=1ll*(i-l[i]+1)*(r[i]-i+1);
    }
    for(int i=2;i<=n;i++){
        cnt[i]+=cnt[i-1];
    }
    while(q--){
        scanf("%s%d",buf,&tmp);
        if(*buf=='>'){
            int x=std::upper_bound(s+1,sed,tmp)-s;
            printf("%lld\n",cnt[sed-s-1]-cnt[x-1]);
        }
        else if(*buf=='='){
            int x=std::lower_bound(s+1,sed,tmp)-s;
            printf("%lld\n",s[x]==tmp?(cnt[x]-cnt[x-1]):0);
        }
        else if(*buf=='<'){
            int x=std::lower_bound(s+1,sed,tmp)-s;
            printf("%lld\n",cnt[x-1]);
        }
    }
    return 0;
}

void Initialize(){
    freopen("jxthree.in","r",stdin);
    freopen("jxthree.out","w",stdout);
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++){
        scanf("%d",a+i);
        s[i]=a[i];
    }
    std::sort(s+1,s+n+1);
    sed=std::unique(s+1,s+n+1);
    std::stack<int> s;
    for(int i=1;i<=n;i++){
        while(!s.empty()&&a[s.top()]<=a[i])
            s.pop();
        l[i]=s.empty()?1:s.top()+1;
        s.push(i);
    }
    Clear(s);
    for(int i=n;i>0;i--){
        while(!s.empty()&&a[s.top()]<a[i])
            s.pop();
        r[i]=s.empty()?n:s.top()-1;
        s.push(i);
    }
}

template<class T> void Clear(T& x){
    T tmp;
    std::swap(tmp,x);
}