[2018 集训队互测 Day 1]完美的队列

Posted 2022-07-15 StaroForgin

完美的队列

题解

首先，我们可以想到求出每个操作的存在时间。
显然，一个操作的存在时间就是它这个操作中一个加入元素被删掉的时间。

我们考虑怎么去维护这东西，一个想法就是去分块。
对于一个块里，产生贡献的操作有两种，一种是没有完全覆盖这个块，但与这个块有交的操作，另一种就是完全覆盖了的操作。
对于第一种操作，总数是$O\left(n\right)$级别的，随便二分什么的一下就行了。
第二种操作，我们可以对于每个块单独计算它的灭亡时间，再把它们取最大值。
对于每个块内，第二类操作会让所有块都减小$1$，所以这个我们只需要知道当前时间点前有多少个二类操作即可，重点时一类操作，这个可以考虑用线段树进行维护。
可以发现，所有都二类操作按时间排序后，它们的灭亡时间是递增的，可以考虑用双指针进行维护。指针在一类操作上移动，二类操作的贡献可以用二分什么的维护。
这样做的时间复杂度是$O\left(n\sqrt{n}\log n\right)$的，显然过不了，考虑优化。

不妨考虑把我们上面的这一堆东西搬到线段树上会怎样。
同样对于线段树上的每个节点，我们考虑它的一二类操作，还会像上面一样维护。
但问题在于完全覆盖它的一类操作会很多，但没关系，我们可以只计算刚好完全覆盖到它的一类操作，其它的一类操作可以扔到线段树上面，用线段树二分去查找。
这样的话所有一类操作和二类操作的个数都是$O\left(n\log n\right)$级别的。
我们可以在最后$dfs$整棵线段树进行统计答案，向下的时候插入该点上的操作到时间线段树里，退出的时候删掉。
在单点是，还是用上面的双指针的方法去计算，这时候只需要考虑二类操作的影响了，与上面分块的做法是一样的。

时间复杂度$O\left(n{\log }^{2}n\right)$，然而时间常数巨大，跑得贼慢。

源码

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
typedef unsigned int uint;
#define MAXN 100005
#define pb push_back
#define mkpr make_pair
#define fir first
#define sec second
#define lson (rt<<1)
#define rson (rt<<1|1)
#define lowbit(x) (x&-x)
const int INF=0x3f3f3f3f;
const int mo=998244353;
template<typename _T>
void read(_T &x)
   _T f=1;x=0;char s=getchar();
   while(s<'0'||s>'9')if(s=='-')f=-1;s=getchar();
   while('0'<=s&&s<='9')x=(x<<3)+(x<<1)+(s^48);s=getchar();
   x*=f;

template<typename _T>
_T Fabs(_T x)return x<0?-x:x;
LL gcd(LL a,LL b)return !b?a:gcd(b,a%b);
int add(int x,int y,int p)return x+y<p?x+y:x+y-p;
void Add(int &x,int y,int p)x=add(x,y,p);
int qkpow(int a,int s,int p)int t=1;while(s)if(s&1)t=1ll*a*t%p;a=1ll*a*a%p;s>>=1;return t;
int n,m,a[MAXN],tim[MAXN],tr[MAXN],las[MAXN];
struct mingint l,r,x;s[MAXN];
class SegmentTree
    private:
        vector<int>vec[MAXN<<2],dif[MAXN<<2];
        int tr[MAXN<<2],val[MAXN<<2],maxx[MAXN<<2];
        void update(int rt,int l,int r,int al,int ar,int aw)
            if(l>r||l>ar||r<al||al>ar)return ;
            if(al<=l&&r<=ar)val[rt]+=aw;maxx[rt]+=aw;return ;
            int mid=l+r>>1;
            if(al<=mid)update(lson,l,mid,al,ar,aw);
            if(ar>mid)update(rson,mid+1,r,al,ar,aw);
            maxx[rt]=max(maxx[lson],maxx[rson])+val[rt];
        
        int query(int rt,int l,int r,int al,int ar)
            if(l>r||l>ar||r<al||al>ar)return -INF;
            if(al<=l&&r<=ar)return maxx[rt];
            int mid=l+r>>1,res=-INF;
            if(al<=mid)res=max(res,query(lson,l,mid,al,ar));
            if(ar>mid)res=max(res,query(rson,mid+1,r,al,ar));
            return res+val[rt];
        
        void insert(int rt,int l,int r,int ai,int aw)
            if(l>r||l>ai||r<ai)return ;tr[rt]+=aw;
            if(l==r)return ;int mid=l+r>>1;
            if(ai<=mid)insert(lson,l,mid,ai,aw);
            if(ai>mid)insert(rson,mid+1,r,ai,aw);
        
        int askSum(int rt,int l,int r,int k)
            if(l==r)return tr[rt];int mid=l+r>>1,res=0;
            if(k<=mid)return askSum(lson,l,mid,k);
            return tr[lson]+askSum(rson,mid+1,r,k);
        
        int ask(int rt,int l,int r,int k)
            if(tr[rt]<k)return m+1;
            if(l==r)return l;int mid=l+r>>1;
            if(tr[lson]>=k)return ask(lson,l,mid,k);
            return ask(rson,mid+1,r,k-tr[lson]); 
        
        void search(int rt,int l,int r)
            if(l==r)printf("%d ",tr[rt]);return ;
            int mid=l+r>>1;search(lson,l,mid);search(rson,mid+1,r);
        
    public:
        void build(int rt,int l,int r)
            if(l==r)val[rt]=maxx[rt]=a[l];return ;
            int mid=l+r>>1;build(lson,l,mid);build(rson,mid+1,r);
            maxx[rt]=max(maxx[lson],maxx[rson])+val[rt];
        
        void modify(int rt,int l,int r,int al,int ar,int aw)
            if(l>r||l>ar||r<al||al>ar)return ;
            dif[rt].pb(aw);int mid=l+r>>1;
            if(al<=l&&r<=ar)vec[rt].pb(aw);return ;
            if(al<=mid)modify(lson,l,mid,al,ar,aw);
            if(ar>mid)modify(rson,mid+1,r,al,ar,aw);
        
        void sakura(int rt,int l,int r)
            int siz=dif[rt].size();
            for(int al=0,ar=0;al<siz;al++)
                int x=dif[rt][al],tp,y;update(1,1,n,s[x].l,s[x].r,1);
                while(ar<=al)y=dif[rt][ar],update(1,1,n,s[y].l,s[y].r,-1),ar++;
                if(s[x].l>l||s[x].r<r)continue;tp=askSum(1,1,m,x);
                int rig=ask(1,1,m,tp+query(1,1,n,l,r))-1;
                while(ar<siz)
                    y=dif[rt][ar];if(y>rig)break;
                    update(1,1,n,s[y].l,s[y].r,-1);
                    int tmp=query(1,1,n,l,r);
                    if(tp+tmp<=askSum(1,1,m,y))
                        update(1,1,n,s[y].l,s[y].r,1);
                        rig=y-1;break;
                    
                    rig=ask(1,1,m,tp+tmp)-1;ar++;
                
                tim[x]=max(tim[x],rig);
            
            if(l==r)return ;int mid=l+r>>1;siz=vec[rt].size();
            for(int i=0;i<siz;i++)insert(1,1,m,vec[rt][i],1);
            sakura(lson,l,mid);sakura(rson,mid+1,r);
            for(int i=0;i<siz;i++)insert(1,1,m,vec[rt][i],-1);
        
T;
void insert(int pos,int aw)while(pos)tr[pos]+=aw,pos-=lowbit(pos);
int query(int pos)int res=0;while(pos<=m)res+=tr[pos],pos+=lowbit(pos);return res;
int main()
    read(n);read(m);
    for(int i=1;i<=n;i++)read以上是关于[2018 集训队互测 Day 1]完美的队列的主要内容，如果未能解决你的问题，请参考以下文章
 
 [集训队互测]calc
 [集训队互测2012]calc——DP
 jzoj 2867. 集训队互测 2012Contra
 LuoguP4463 [集训队互测2012] calc DP+拉格朗日插值
 jzoj 2866. 集训队互测 2012Bomb
 UOJ#191. 集训队互测2016Unknown