P3603 雪辉 题解

前言

• 正解是树分块，但是用重剖
• 开玩笑的重剖也是正解
• 最开始胡的是重剖莫队

\(\mathcal{solve}\)

• 在一个树上操作，不带修，求一堆并，一个一个来
• 在树上操作，由于不会树分块，考虑转成序列，重剖是很好用的
• 重剖后的树是支持从 \(x\) 到 \(y\) 最短路径这一类查询进行区间查询的，所以可以通过区间操作直接查询
• 考虑一个区间数的出现情况，且要求进行或运算，bitset 可以轻松维护而且还能创常数
• 然后就只剩维护一个连续区间了，由于线段树啥的完全没法维护，要求在线，选择分块，每块预处理出这个块的数出现的次数，查询时整块直接拿，散块暴力查，实现不难且完全不卡常，Ynoi 为数不多的小清新
• 不过有一些要注意的，你学过分块和重剖就都会注意到的

1. 在序列操作时，要把 \(\mathcal{dfn}\) 还原（求 \(\mathcal{dfn}\) 时再反着存一个数组就行，msjing用的 \(rnk\)），要不然对不上但是样例能过
2. 分块一定要分块

\(\mathcal{code}\)

点击查看代码

#include <bits/stdc++.h>
using namespace std;
constexpr int maxn=2e5+10;
int read()
{
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0' || ch>'9')
    {
        if (ch == '-') f=-1;
        ch=getchar();
    }
    while (ch>='0' && ch<='9')
    {
        x=(x<<1)+(x<<3)+ch-'0';
        ch=getchar();
    }
    return x*f;
}
int n,m,F;
int a[maxn];
int h[maxn],to[maxn],nxt[maxn],tot;
void addedge(int x,int y)
{
    tot++;
    to[tot]=y;
    nxt[tot]=h[x];
    h[x]=tot;
}
namespace TLPD
{
    int siz[maxn],son[maxn],fa[maxn],dep[maxn];
    int dfn[maxn],rnk[maxn],top[maxn],cnt;
    void dfs1(int x)
    {
        siz[x]=1,son[x]=-1;
        for (int i=h[x];i;i=nxt[i])
        {
            int y=to[i];
            if (dep[y]) continue;
            dep[y]=dep[x]+1;
            fa[y]=x;
            dfs1(y);
            siz[x]+=siz[y];
            if (son[x] == -1 || siz[y]>siz[son[x]])
                son[x]=y;
        }
    }
    void dfs2(int x,int t)
    {
        top[x]=t;
        dfn[x]=++cnt,rnk[cnt]=x;
        if (son[x] == -1) return;
        dfs2(son[x],t);
        for (int i=h[x];i;i=nxt[i])
        {
            int y=to[i];
            if (y == fa[x] || y == son[x]) continue;
            dfs2(y,y);
        }
    }
}using namespace TLPD;
int L[maxn],R[maxn],pos[maxn];
bitset<maxn/2> t[320][320],g;
void init()
{
    int b=n/sqrt(m)+1;
    int ct=n/b;
    for (int i=1;i<=ct;i++)
        L[i]=R[i-1]+1,R[i]=b*i;
    if (R[ct]<n)
        ct++,L[ct]=R[ct-1]+1,R[ct]=n;
    for (int i=1;i<=ct;i++)
        for (int j=L[i];j<=R[i];j++)
            pos[j]=i,t[i][i].set(a[rnk[j]]);
    for (int i=1;i<ct;i++)
        for (int j=i+1;j<=ct;j++)
            t[i][j]=t[i][j-1]|t[j][j];
}
void que(int x,int y)
{
    if (pos[x] == pos[y])
        for (int i=x;i<=y;i++) g.set(a[rnk[i]]);
    else
    {
        g|=t[pos[x]+1][pos[y]-1];
        for (int i=x;i<=R[pos[x]];i++) g.set(a[rnk[i]]);
        for (int i=L[pos[y]];i<=y;i++) g.set(a[rnk[i]]);
    }
}
void query(int x,int y)
{
    while (top[x]!=top[y])
    {
        if (dep[top[x]]<dep[top[y]]) swap(x,y);
        que(dfn[top[x]],dfn[x]);
        x=fa[top[x]];
    }
    if (dep[x]>dep[y]) swap(x,y);
    que(dfn[x],dfn[y]);
}
int main()
{
    // freopen("787878.out","w",stdout);
    n=read(),m=read(),F=read();
    for (int i=1;i<=n;i++) a[i]=read();
    for (int i=1;i<n;i++)
    {
        int x=read(),y=read();
        addedge(x,y),addedge(y,x);
    }
    dep[1]=1;
    dfs1(1),dfs2(1,1);
    init();
    int lt=0;
    while (m--)
    {
        int A=read();
        int x,y;
        g.reset();
        for (int i=1;i<=A;i++)
        {
            x=read(),y=read();
            if (F) x^=lt,y^=lt;
            query(x,y);
        }
        int cont=g.count(),id=1e5+10;
        for (int i=0;i<=1e5;i++)
            if (!g[i]) {id=i;break;}
        printf("%d %d\n",cont,id);
        lt=cont+id;
    }
    return 0;
}

后话

• 这题还是简单的估计是树分块撑到了\(\color{purple}{紫}\)，重剖做真没多难，学了树分块后再来做一遍
• 什么时候学呢