Ynoi 2014-2015 做题记录

在太阳西斜的这个世界里，

置身天上之森。

等这场战争结束之后，

不归之人与望眼欲穿的众人，

人人本着正义之名，

长存不灭的过去、逐渐消逝的未来。

我回来了，

纵使日薄西山，

即便看不到未来，

此时此刻的光辉，

盼君勿忘。

————世界上最幸福的女孩

P5064 [Ynoi2014] 等这场战争结束之后

简要题意

双倍经验：LOJ 519 给定一个 $$ 个点的无向图，点有点权，最开始没有边，需要进行以下操作 $$ 次：

• 在 $$ 和 $$ 之间加一条边。
• 撤回到第 $$ 次操作之后的状态。
• 询问在 $$ 所在连通块中第 $$ 小的点权。

$$。

时间限制：$$，内存限制：$$。 LOJ 上时空限制略宽。

解法

线段树合并应该不能可持久化，因为线段树合并复杂度是均摊的。

值域分块

不考虑内存限制，进行值域分块。强行将点权离散化成一个长为 $$ 的排列，在相等时也要钦定一个顺序，这样离散化完每个值都唯一对应一个点。在值域上每 $$ 个分为一块，使用并查集维护联通性，在并查集的根上开一个 $$ 的数组，记录在每一块内的数在当前连通块内分别出现的次数。合并时将两个根上的数组对应位置相加。查询时从小到大枚举每个块，即可确定 $$ 出现在的块。然后枚举这个块内所有数，判断这个数对应的点是否和查询的点在同一联通块内，容易求出第 $$ 小所对应的点权。现在考虑回退版本。离线所有操作，将一个操作与依赖的版本之间连边，能构成一棵树，称之为操作树。在操作树上进行 dfs，进入一个点的时候执行对应位置的操作，在离开这个点的时候如果对应操作为修改，撤销对应的修改。这样只需维护可撤销并查集，使用按秩合并或启发式合并，每次记录修改的内容到一个栈中，撤回时将栈顶的操作撤销即可。时间复杂度 $$，当 $$ 时复杂度最优，为 $$，对应的空间复杂度为 $$。在本题内存限制下难以通过。

现在考虑优化内存，枚举块，每次仅记录一个块的信息，遍历操作树进行操作，判断是否在这个块内，如果是则枚举每个数，检查是否在同一连通块中。我们发现对于每个块来说，在并查集上的操作相同，只是维护的内容不同，需要预处理出每次合并及查询的点的根，否则时间复杂度会退化到 $$，这样空间复杂度被优化到 $$，由于要多次遍历操作树，建议使用操作树的 dfs 序，此处应选用出栈入栈序。该种做法可以通过此题。

考虑进一步优化时间复杂度。处理出第 $$ 小所在的块同上述。在块内查询时，弃用并查集，对于操作树进行树分块，此处需要的树分块应满足关键点是整个块内深度最浅的点，并且块内每个点都距离关键点不超过 $$。进行每个关键点到根节点的路径上所有连边操作，不难通过一次 dfs 或 bfs 来获得每个点所属的连通块，每次询问时将这个询问到关键点所有的连边操作也进行，只需遍历这 $$ 条边即可得到每个点在此次询问的时候的所属连通块信息，只要逐块处理空间即为 $$，时间复杂度为 $$，当 $$ 时取到最优，为 $$。

bitset

同样的将点权离散化为一个长为 $$ 的排列，不难想到找第 $$ 小可以拿 bitset 优化（需要手写 bitset，STL 中的 bitset 不支持）。仍然离线建操作树，使用可撤销并查集维护连通性，在并查集的根维护一个 bitset，合并时将两个 bitset 取并集，撤销时两个 bitset 取差集，查询时直接在 bitset 中查。时间复杂度 $$，空间复杂度 $$。在本题内存限制下难以通过。

考虑一种朴素的暴力。在并查集的根维护一个链表，每次合并的时候直接将链表拼接到一起，并且记录长度，在撤回的时候根据长度分裂为两个链表。查询的时候将这个并查集根的链表所有元素拿出来，使用 nth_elemant 找第 $$ 小。不难发现，一个元素只会出现在一个链表里，空间复杂度 $$，时间复杂度 $$。

考虑数据分治，设阈值 $$。如果一个连通块内元素个数少于 $$，则使用链表维护，当超过 $$ 时使用 bitset 维护，由于单个 bitset 中元素至少为 $$，所以至多只用 $$ 个 bitset，空间复杂度 $$，由于链表内元素至多 $$ 个，所以时间复杂度 $$。

Code

在实现时需要注意特判回退到的版本的最后一次操作仍然是一个回退操作的情况。此份代码为时间 $$，空间 $$ 的做法。

namespace lly
{
    constexpr int N=1e5+5,B=1300,BB=1305;
    namespace dsu
    {
        int fa[N],siz[N],rsiz[N];
        inline void init(int n){for(int i=1;i<=n;i++)fa[i]=i,siz[i]=1,rsiz[i]=0;}
        inline int find(int x){while(fa[x]!=x)x=fa[x];return x;}
        struct dat{int x,y;}stk[N];int top=0;
        inline void merge(int x,int y)
        {
            if(siz[x]<siz[y])swap(x,y);
            stk[++top]=(dat){x,y};
            if(x==y)return;
            siz[x]+=siz[y];rsiz[x]+=rsiz[y];fa[y]=x;
        }
        inline void undo()
        {
            int x=stk[top].x,y=stk[top].y;top--;
            if(x==y)return;
            fa[y]=y;siz[x]-=siz[y];rsiz[x]-=rsiz[y];
        }
    }
    int n,m;
    struct edge{int to,nxt;}e[N<<1];
    int head[N],cnt=0;
    inline void add(int u,int v)
    {
        e[++cnt]=(edge){v,head[u]};
        head[u]=cnt;
    }
    int a[N],ord[N],b[N],bel[N],L[N],R[N],bsiz,dfn[N<<1],ans[N],idx=0;
    struct Q{int op,x,y;}q[N];
    inline void dfs(int u)
    {
        if(u)
        {
            dfn[++idx]=u;
            if(q[u].op==1)
            {
                int x=dsu::find(q[u].x),y=dsu::find(q[u].y);
                q[u]=(Q){1,x,y};dsu::merge(x,y);
            }
            else q[u].x=dsu::find(q[u].x);
        }
        for(int i=head[u];i;i=e[i].nxt){int v=e[i].to;dfs(v);}
        if(u){dfn[++idx]=-u;if(q[u].op==1)dsu::undo();}
    }
    int pre[N];
    inline void work()
    {
        using IO::qread;using IO::qwrite;using IO::pc;
        qread(n),qread(m);
        for(int i=1;i<=n;i++)qread(a[i]),ord[i]=i;
        sort(ord+1,ord+n+1,[](const int x,const int y)->bool{return a[x]<a[y]||(a[x]==a[y]&&x<y);});
        for(int i=1;i<=n;i++)b[ord[i]]=i;
        for(int i=1;i<=n;i++)bel[i]=(i-1)/B+1,R[bel[i]]=i,L[bel[i]]=(L[bel[i]]?L[bel[i]]:i);
        bsiz=bel[n];
        int now=0;
        for(int i=1;i<=m;i++)
        {
            int op,x,y;qread(op),qread(x);
            if(op==2){if(!q[x].op)pre[i]=pre[x];else pre[i]=x;now=pre[i];continue;}
            qread(y),add(now,i),now=i,q[i]=(Q){op,x,y};
        }
        dsu::init(n);
        dfs(0);
        for(int i=1;i<=bsiz;i++)
        {
            dsu::init(n);
            for(int j=1;j<=n;j++) if(L[i]<=b[j]&&b[j]<=R[i]) dsu::rsiz[j]=1;
            for(int j=1;j<=idx;j++)
            {
                if(dfn[j]>0)
                {
                    int u=dfn[j];
                    if(q[u].op==1) dsu::merge(q[u].x,q[u].y);
                    else if(q[u].op==3)
                    {
                        if(q[u].y)
                        {
                            int w=dsu::rsiz[q[u].x];
                            if(q[u].y>w) q[u].y-=w;
                            else for(int k=L[i];k<=R[i];k++)
                            {
                                if(dsu::find(ord[k])==q[u].x) q[u].y--;
                                if(!q[u].y){ans[u]=ord[k];break;}
                            }
                        }
                    }
                }
                else{int u=-dfn[j];if(q[u].op==1)dsu::undo();}
            }
        }
        for(int i=1;i<=m;i++) if(q[i].op==3) qwrite(ans[i]?a[ans[i]]:-1),pc('\n');
    }
}
CPP

P5068 [Ynoi2015] 我回来了

简要题意

你需要维护一个可重集，需要进行以下两种操作 $$ 次：

• 加入一个数 $$，保证 $$。
• 定义关于 $$ 的一次操作为将可重集内所有数都减去 $$。如果在操作后可重集内的正数个数减少，则会继续操作，否则停止。询问一个区间 $$，将在这个区间内等概率的随机出一个整数 $$，求关于 $$ 的操作次数的期望乘上 $$，询问之间是独立的。

$$。

时间限制 $$，内存限制 $$。

解法

首先查询就是 $$ 内所有数的操作次数之和。关于 $$ 的操作次数的本质，查找 $$ 中从第一个没有数出现的区间。我们发现总的区间个数为 $$。

在线

随着数的加入，对于每个数 $$ 来说，关于 $$ 的操作次数单调不降，对于每个数 $$ 维护一个双指针状物，每次加入一个值后，把所有当前没有数出现的区间中包含这个数的区间标记为已有数，同时更新那个区间对应的 $$ 的指针，即将 $$ 的指针往后移动，直到遇到一个没有被标记过的区间。由于需要区间查询操作次数，维护一棵树状数组，更新完 $$ 的指针后在树状数组上更改 $$ 对应的值为新的操作次数。由于每个区间只会被标记一次，所以最多 $$ 次后移指针和修改树状数组上值的操作，时间复杂度为 $$。查询直接在树状数组上区间查，时间复杂度 $$。

考虑如何快速维护包含某个数的区间，方法较多，此处介绍一种比较容易实现的。开 $$ 个 vector，将区间 $$ 放到 $$ 对应的 vector，vector 内按 $$ 排序，用一棵线段树维护每个 vector 中最后一个区间的 $$ 的区间最大值。每次查询时在线段树上查询 $$ 对应的最大值是否大于 $$，如果是则找到最大值对应的 $$，取出最后一个，更新线段树上的信息，并且继续操作。每个区间至多被取出一次，时间复杂度 $$。至此，我们有了一个 $$ 的在线做法。

离线

离线，处理出 $$ 表示 $$ 第一次出现的时刻，记 $$ 表示对于 $$ 的第 $$ 个区间第一次有数的时刻，即为这个区间内 $$ 的最小值，使用 ST 表维护。由于一个区间有贡献必须前面的区间都有值，所以计算 $$，只要时刻大于 $$，则就会给包含 $$ 的询问贡献 $$，按照 $$ 加入区间，使用树状数组统计贡献即可。时间复杂度 $$。

Code

离线做法

namespace lly
{
    constexpr int N=1e5+5,M=1e6+5;
    int a[N];
    namespace ST
    {
        int f[21][N],lg[N];
        inline void init(int n)
        {
            lg[0]=-1;
            for(int i=1;i<=n;i++)lg[i]=lg[i>>1]+1,f[0][i]=a[i];
            for(int i=1;i<=20;i++)for(int j=1;j+(1<<i)-1<=n;j++)f[i][j]=min(f[i-1][j],f[i-1][j+(1<<(i-1))]);
        }
        inline int query(int l,int r){int k=lg[r-l+1];return min(f[k][l],f[k][r-(1<<k)+1]);}
    }
    struct Q{int l,r;}q[M];
    vector<int>d[M];
    namespace BIT
    {
        int c[N];constexpr int R=1e5+1;
        inline int lowbit(int x){return x&(-x);}
        inline void update(int x){while(x<=R)c[x]++,x+=lowbit(x);}
        inline int query(int x){int ret=0;while(x)ret+=c[x],x-=lowbit(x);return ret;}
    }
    inline void work()
    {
        using namespace IO;int n,m;cin>>n>>m;
        for(int i=1;i<=n;i++)a[i]=m+1;
        for(int i=1;i<=m;i++)
        {
            int op,l,r;cin>>op;
            if(op==1)cin>>l,a[l]=min(a[l],i);
            else cin>>l>>r,q[i]=(Q){l,r};
        }
        ST::init(n);
        for(int i=1;i<=n;i++)
        {
            int pre=0;
            for(int j=1;j<=n;j+=i)
            {
                int now=ST::query(j,min(i+j-1,n));
                pre=max(pre,now);
                d[pre].emplace_back(i);
            }
        }
        for(int i=1;i<=m;i++)
        {
            for(int j:d[i]) BIT::update(j);
            if(q[i].l) qwrite(BIT::query(q[i].r)-BIT::query(q[i].l-1)+q[i].r-q[i].l+1),pc('\n');
        }
    }
}
CPP