CF1529E

传送门

[大佬视频讲解](【算法题解】Codeforces Round #722 (Div. 2) 二营长的意大利炮会旋转_哔哩哔哩_bilibili)

题目大意

有两张图共享n个节点

可以给$u,v$结点加边，如果同时满足：

1. 在S的树中，$u/v$是另一个的祖先
2. 在K的树中，$u/v$不是另一个的祖先

求最大的团

思路

条件一：节点都在从1出发的链上

条件二：两两不是祖先关系

在第二棵树上不是很好处理，所以我们从第一颗树上跑dfs，边跑边选择一些节点，这些节点要满足在根节点到当前节点的路径上

对于第二棵树，可以使用数据结构维护，线段树/set

采用dfs序，如果在树2中选择了一个节点，那么这个节点的祖先和儿子都不能选择，把不可以选择的区间染色，当你需要查询一个节点是否可以被选择时，

1. 只需要看这个节点有没有被染色，如果被染色，就代表这个节点的祖先节点被选择了
2. 如果当前节点到底层节点之间有没有节点被染色，如果有节点被染色，就代编这个节点的孙子节点被选择了

如果使用set来维护，选择一个节点以后，就直接把当前节点的dfs序直接插入set中，如果需要查询他的祖先或者他的孙子是否能被选择，二分查找第一个大于等于他的最小值，或小于等于他的最大值，要么和它没关系，要么就是他的祖先或孙子

已选节点中有几种情况：

1. 没有x的祖先或孙子，直接选
2. 有x的祖先或孙子，考虑保留x的祖先好，还是x好，选x好，因为如果选祖先，祖先的子树也不能选择了

// https://codeforc.es/contest/1529/problem/E
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N = 3e5 + 10, M = 3e5 + 10;

struct Seg_Tree {
    struct {
        int l, r;
        ll dat, inc;
    } t[M * 4];

    void build(int p, int l, int r) {
        t[p].l = l, t[p].r = r;
        t[p].inc = -1;
        if (l == r) {
            t[p].dat = 0;
            return;
        }
        int mid = (l + r) >> 1;
        build(p << 1, l, mid);
        build(p << 1 | 1, mid + 1, r);
        t[p].dat = max (t[p << 1].dat, t[p << 1 | 1].dat);
    }

    void change(int p, int le, int re, ll v) {
        if (t[p].l == le && t[p].r == re) {
            t[p].dat = v;
            t[p].inc = v;
            return;
        }
        if (t[p].inc > - 1)
        {
            t[p << 1].dat = t[p << 1 | 1].dat = t[p].inc;
            t[p << 1].inc = t[p << 1 | 1].inc = t[p].inc;
            t[p].inc = -1;
        }
        int mid = (t[p].l + t[p].r) >> 1;
        if (re <= mid)
            change(p << 1, le, re, v);
        else if (le > mid)
            change (p << 1 | 1, le, re, v);
        else 
        {
            change (p << 1, le, mid, v);
            change(p << 1 | 1, mid + 1, re, v);
        }
        t[p].dat = max(t[p << 1].dat, t[p << 1 | 1].dat);
    }

    ll ask(int p, int l, int r) {
        if (l == t[p].l && r == t[p].r)return t[p].dat;
        if (t[p].inc > - 1)
        {
            t[p << 1].dat = t[p << 1 | 1].dat = t[p].inc;
            t[p << 1].inc = t[p << 1 | 1].inc = t[p].inc;
            t[p].inc = -1;
        }
        int mid = (t[p].l + t[p].r) >> 1;
        ll val;
        if (r <= mid)val = ask(p << 1, l, r);
        else if (l > mid)val = ask(p << 1 | 1, l, r);
        else
            val = max (ask (p << 1, l, mid), ask (p << 1 | 1, mid + 1, r));
        return val;
    }
} Sg;

// dfn represents dfs sequence
// edn represents the lagest number of nodes
int n, cnt, deep[N], dfn[N], edn[N], dp[N];
vector <int> e1[N], e2[N];

void init ()
{
    for (int i = 1; i <= n; i ++)
    {
        e1[i].clear ();
        e2[i].clear ();
    }
    cnt = 0;
}

bool isfa (int x, int p)
{
    return dfn[x] >= dfn[p] && dfn[x] <= edn[p];
}

// preprocess the dfs sequence
void dfs1 (int x)
{
    dfn[x] = ++ cnt;
    for (auto c : e1[x])
        dfs1 (c);
    edn[x] = cnt;
}

void dfs2 (int x, int fa)
{
    // tmp represent the value interval of x's dfs sequence of its subtree 
    int tmp = Sg.ask (1, dfn[x], edn[x]);
    if (tmp)
    {
        dp[x] = dp[fa];
        // greeedy choose son nodes
        if (isfa (x, tmp))
        {
            Sg.change (1, dfn[tmp], edn[tmp], 0);
            Sg.change (1, dfn[x], edn[x], x);
        }
    }
    // if the value equals to 0, it means the curent node can be chosen, dp[x] = dp[fa] + 1
    // meanwhile, we assign x to the interval of x's subtree 
    else 
    {
        dp[x] = dp[fa] + 1;
        Sg.change (1, dfn[x], edn[x], x);
    }

    for (auto c : e2[x])
        dfs2 (c, x);
    
    if (tmp)
    {
        if (isfa (x, tmp))
            Sg.change (1, dfn[tmp], edn[tmp], tmp);
    }
    else
        Sg.change (1, dfn[x], edn[x], 0);
}

int main ()
{
    int T;
    cin >> T;
    while (T --)
    {
        cin >> n;
        init ();
        for (int i = 2; i <= n; i ++)
        {
            int tmp;
            cin >> tmp;
            e2[tmp].push_back (i);
        }
        for (int i = 2; i <= n; i ++)
        {
            int tmp;
            cin >> tmp;
            e1[tmp].push_back (i);
        }
        dfs1 (1);
        Sg.build (1, 1, n);
        dfs2 (1, 0);
        int ans = 0;
        for (int i = 1; i <= n; i ++)
            ans = max (ans, dp[i]);
        cout << ans << endl;
    }
}