Codeforces Round #722 (Div. 1) C（dfs序+树状数组）&& 2021牛客多校第七场F-xay loves trees

Codeforces Round #722 (Div. 1) C

题目思路

题目给了两个条件：
1.集合中任意两个数在第一颗树中任意一点为另一点的祖先
2.集合中任意两个数在第一棵树中互不为祖先
对于第二个条件，我们可以用dfs序来判断，如果两点的覆盖的区间不存在重复，那么他们一定不互为祖先。
又根据条件一我们可以发现这些点一定在第一棵树的同一条链上，
所以我们可以先将第二棵树的dfs序求出来，在遍历第一棵树来求解。
我们用树状数组来维护已被覆盖的区间的信息。
当我们遍历到一个新的点x时，我们先查询它在dfs序上第一次出现的位置是否被覆盖。
如果该位置未被覆盖，那么说明我们选择进答案集合的这些点在第二棵树中都不是他的祖先，将它加入答案集合。
如果该位置被覆盖，那么我们先找到覆盖该区间的点y，因为我们要让区间尽量少的被覆盖，所以我们肯定是选择覆盖区间小的点，题目又说限制了祖先节点一定小于儿孙结点，那么我们就清空y覆盖的区间，并覆盖x对应的区间。

ac代码

int n,cnt,ans;
int a[maxn],b[maxn];
int tim,in[maxn],out[maxn];
vector<int>vec1[maxn],vec2[maxn];

struct Tree_array {
    int arr[maxn];
    void Add(int x, int y) {//单点修改
        while (x < maxn)
            arr[x] += y, x += lowbit(x);
    }
    void Seg_Add(int l, int r, int x) {//数组差分后，区间修改
        Add(l, x);
        Add(r + 1, -x);
    }
    int Query(int x) {//1到x的和
        int res = 0;
        while (x)
            res += arr[x], x -= lowbit(x);
        return res;
    }
} tree;


void dfs(int x,int fa)
{
    in[x]=++tim;
    for(auto i:vec2[x])
    {
        int to=i;
        if(to==fa)continue;
        dfs(to,x);
    }
    out[x]=tim;
}

void init()
{
    for(int i=1;i<=n;i++)
    {
        vec1[i].clear();
        vec2[i].clear();
        in[i]=0;
        out[i]=0;
    }
    tim=cnt=ans=0;
}

void dfs2(int u)
{
    int fa=tree.Query(in[u]);
    if(fa)
        tree.Seg_Add(in[fa],out[fa],-fa);
    else cnt++;
    ans=max(ans,cnt);
    tree.Seg_Add(in[u],out[u],u);
    for(auto x:vec1[u])
        dfs2(x);
    tree.Seg_Add(in[u],out[u],-u);
    if(fa)
        tree.Seg_Add(in[fa],out[fa],fa);
    else
        cnt--;
}

int main()
{
    int _;
    scanf("%d",&_);
    while(_--)
    {
        scanf("%d",&n);
        init();
        for(int i=2,x;i<=n;i++)
        {
            scanf("%d",&x);
            vec1[x].push_back(i);
        }
        for(int i=2,x;i<=n;i++)
        {
            scanf("%d",&x);
            vec2[x].push_back(i);
        }
        dfs(1,-1);
        dfs2(1);
        printf("%d\n",ans);
    }
}

2021牛客多校第七场F-xay loves trees

题目思路

这题跟上题的题意基本一样，但是加了个条件，要求子集中的点在第一棵树中是联通的。
换句话说，就是这个集合是第一棵树上的某个链上的连续段。
所以我们没法像上题一样直接暴力遍历每条链然后删除覆盖的点。
网上有很多做法，但是我觉得滑动窗口的做法最容易理解。
基本思路跟上题一样，先对第二棵树求dfs序。
然后我们遍历第一棵树的链，每次遍历到一个点时，我们将他在第二棵树中的子树覆盖，即子树加一，然后判断整个树中是否有大于1的值（线段树维护的是区间最大值），如果有我们就删除单调队列的起点对应区间，并且将起点前移。
然后找这样遍历下去。
需要注意的是回溯的操作，手写的在单调队列中我们每次删除头部的值时只是让指针移动，所以前面的值仍然保存在数组中，我们记录递归前移动的距离，在这个时候重新移回去就行了。

ac代码

int n,cnt,ans;
int a[maxn],b[maxn];
int tim,in[maxn],out[maxn];
vector<int>vec1[maxn],vec2[maxn];
int t[maxn<<4],lz[maxn<<4];

void pushup(int rt)
{
    t[rt]=max(t[lson],t[rson]);
}

void build(int rt,int l,int r)
{
    lz[rt]=0;
    if(l==r)
    {
        t[rt]=0;
        return;
    }
    int mid=(l+r)>>1;
    build(lson,l,mid);
    build(rson,mid+1,r);
    pushup(rt);
}

void pushdown(int rt)
{
    if(lz[rt])
    {
        lz[lson]+=lz[rt];
        lz[rson]+=lz[rt];
        t[lson]+=lz[rt];
        t[rson]+=lz[rt];
        lz[rt]=0;
    }
}

void update(int rt,int l,int r,int L,int R,int v)
{
    if(L<=l&&r<=R)
    {
        t[rt]+=v;
        lz[rt]+=v;
        return;
    }
    int mid=(l+r)>>1;
    pushdown(rt);
    if(L<=mid)
        update(lson,l,mid,L,R,v);
    if(R>mid)
        update(rson,mid+1,r,L,R,v);
    pushup(rt);
}

int query(int rt,int l,int r,int L,int R)
{
    if(L<=l&&r<=R)
    {
        return t[rt];
    }
    int mid=(l+r)>>1;
    pushdown(rt);
    int ans=0;
    if(L<=mid)
        ans=max(ans,query(lson,l,mid,L,R));
    if(R>mid)
        ans=max(ans,query(rson,mid+1,r,L,R));
    return ans;
}

void dfs(int x,int fa)
{
    in[x]=++tim;
    for(auto i:vec2[x])
    {
        int to=i;
        if(to==fa)continue;
        dfs(to,x);
    }
    out[x]=tim;
}

void init()
{
    for(int i=1;i<=n;i++)
    {
        vec1[i].clear();
        vec2[i].clear();
        in[i]=0;
        out[i]=0;
    }
    tim=cnt=ans=0;
}

int q[maxn];
int head,si;

void dfs2(int u,int fa,int xx)
{
    int mo=0;

    update(1,1,n,in[u],out[u],1);
    while(t[1]>1)
    {
        int x=q[head];
        update(1,1,n,in[x],out[x],-1);
        head++;//维护队首
        mo++;
        si--;
    }
    si++;
    q[xx]=u;
    ans=max(ans,si);
    for(auto i:vec1[u])
    {
        int to=i;
        if(to==fa)continue;
        dfs2(to,u,xx+1);
    }
    while(mo)
    {
        head--;
        int x=q[head];
        update(1,1,n,in[x],out[x],1);
        mo--;
        si++;
    }
    si--;
    update(1,1,n,in[u],out[u],-1);
}




int main()
{
    int _;
    scanf("%d",&_);
    while(_--)
    {
        scanf("%d",&n);
        for(int i=1,u,v;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            vec1[u].pb(v);
            vec1[v].pb(u);
        }
        for(int i=1,u,v;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            vec2[u].pb(v);
            vec2[v].pb(u);
        }
        build(1,1,n);
        dfs(1,-1);
        head=1,si=0,ans=0;
        dfs2(1,-1,1);
        printf("%d\n",ans);
        init();
    }
}