Educational Codeforces Round 65 E,F

E. Range Deleting

题意：给出一个序列，定义一个操作f(x,y)为删除序列中所有在[x,y]区间内的数。问能使剩下的数单调不减的操作f(x,y)的方案数是多少。

解法：不会做，思维跟不上，双指针也不熟练。思路和代码都是学习https://edwiv.com/archives/587这位巨佬的。

说下我的理解：我们考虑怎样的操作[l,r]才是合理的？很容易能想到有3个条件：①删除后剩下的数字[1,l-1]的位置是单调递增，②数字[r+1,x]的位置也是单调递增的，3 数字l-1的所有位置都要比r+1小。那么我们的任务就是预处理这个序列使得能快速判断这3个条件。

posmin[maxn] posmax[maxn]表示每个数下标的最小值和最大值
premax[maxn] sufmin[maxn]表示[1,i]/[i,x]范围内的数出现的下标值的最大值/最小值
precan[maxn] sufcan[maxn]表示[1,i]是否合法，[i,x]是否合法

然后判断[l,r]是否是一个合理操作的条件就是：precan[l-1] && sufcan[r+1] && (premax[l-1]<sufmin[r+1]);  //这分别对应上面的3个条件

那么到这里我们就能够O(1)快速判断某个操作是否合法，接下来就是统计答案。当然不能n^2统计会超时，这里用到双指针的技巧，枚举左端点l，右端点r由上一个左端点l-1的r继承而来，之后再实际判断移动得到当前左端点l的应该右端点r，就可以统计答案贡献就是x-r+1咯。这里的正确性是基于：[l,r]是合理的那么l+1的r必定大于l的r，左右端点是同步递增的。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=1e6+10;
int n,x,a[N];
int posmin[N],posmax[N],premax[N],sufmin[N];
bool precan[N],sufcan[N];

bool check(int l,int r) {  //判断删去区间[l,r]后是否得到合理答案 
    return precan[l-1] && sufcan[r+1] && (premax[l-1]<sufmin[r+1]);
}

int main()
{
    cin>>n>>x;
    memset(posmin,0x3f,sizeof(posmin));
    memset(posmax,0,sizeof(posmax));
    for (int i=1;i<=n;i++) {
        scanf("%d",&a[i]);
        posmin[a[i]]=min(posmin[a[i]],i);
        posmax[a[i]]=max(posmax[a[i]],i);
    }
    for (int i=1;i<=x;i++) premax[i]=max(premax[i-1],posmax[i]);
    sufmin[x+1]=n+1; for (int i=x;i;i--) sufmin[i]=min(sufmin[i+1],posmin[i]);
    memset(precan,0,sizeof(precan)); precan[0]=1;
    for (int i=1;i<=x;i++) precan[i]=precan[i-1]&&(posmin[i]>premax[i-1]);
    memset(sufcan,0,sizeof(sufcan)); sufcan[x+1]=1;
    for (int i=x;i;i--) sufcan[i]=sufcan[i+1]&&(posmax[i]<sufmin[i+1]);
    
    LL ans=0;
    int l=1,r=1;  //双指针 
    for (;l<=x;l++) {  //左指针遍历 
        if (l>r) r=l;
        while (r<x && !check(l,r)) r++;  //移动右指针
        if (check(l,r)) ans+=(x-r+1);  //累加左指针为l时候的贡献为(x-r+1)
    }
    cout<<ans<<endl;
    return 0;
}

F. Scalar Queries

解法：虽然能猜到是算排名贡献乘以数字得到答案，但是还是没做出来qwq。参考https://www.cnblogs.com/carcar/p/10877964.html这位巨佬的。

讲一下自己的理解：容易发现其实答案就是算d[i]*a[i]。这个d[i]系数其实就是所有包含a[i]这个数的区间的a[i]的排名总和。那么怎么样才能快速算得这个d[i]？我们从贡献这个角度思考：

在a[i]的左边，只有a[j]<a[i]（j<i）的时候a[j]对a[i]才会有提升排名的作用，并且这个提升一个排名的效果在所有包含了(a[j]和a[i]）的区间都有效。

同理的，在a[i]的右边，只有a[j]<a[i]（j<i）的时候才有提升排名的作用，并且在所有包含a[j]和a[i]的区间有效。

然后对于a[i]自己也是同理，自己给自己提升了一个排名。

那么我们怎么快速算 a[j]<a[i] 且所有包含了a[j] a[i]的区间个数呢？以a[i]左边为例分析，仔细观察发现其实区间个数就是j*(n-i+1)，对于每个a[j]这个因子j是不会改变的，然后对于a[i]这个因子(n-i+1)也是不会改变的。我们要做的就是快速统计所有a[j]<a[i]的因子j的总和，嗯？这不就是树状数组。对，我们从左到右扫一遍利用树状数组统计，从右往左扫一遍，统计得出d[i]之后此题就解决了。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=5e5+10;
const int P=1e9+7;
int n,m,a[N],b[N],rk[N];
LL d[N];

LL sum[N];
void update(int x,int v) {
    for (;x<=n;x+=x&-x) sum[x]+=v,sum[x]%=P;
}
LL query(int x) {
    LL ret=0;
    for (;x;x-=x&-x) ret+=sum[x],ret%=P;
    return ret;
}

int main()
{
    cin>>n;
    for (int i=1;i<=n;i++) scanf("%d",&a[i]),b[i]=a[i];
    sort(b+1,b+n+1);
    for (int i=1;i<=n;i++) rk[i]=lower_bound(b+1,b+n+1,a[i])-b;
    
    for (int i=1;i<=n;i++) {  //计算[1,i-1]区间的贡献 
        d[i]=(d[i]+query(rk[i]-1)*(n-i+1)%P)%P;
        update(rk[i],i);
    }
    for (int i=1;i<=n;i++) d[i]=(d[i]+(LL)i*(n-i+1)%P)%P;  //计算[i,i]的贡献 
    memset(sum,0,sizeof(sum));
    for (int i=n;i;i--) {  //计算[i+1,n]的贡献 
        d[i]=(d[i]+query(rk[i]-1)*(i)%P)%P;
        update(rk[i],n-i+1);
    }
    
    LL ans=0;
    for (int i=1;i<=n;i++) ans=(ans+a[i]*d[i]%P)%P;
    cout<<ans<<endl;
    return 0;
}