F-xay loves trees（2021牛客暑期多校训练营7）【双指针+树链剖分+线段树维护最大值】

F-xay loves trees（2021牛客暑期多校训练营7）

相对比较简单的一道树链剖分，推荐刚学的同学尝试

题意

给定两个树，找一个最大的子图，使得在第一棵树中任意两个节点互为祖先-子孙关系，在第二棵树中任意两个节点互不为祖先-子孙节点关系。

思路

参考：2021牛客暑期多校训练营7 F - xay loves trees - naymi - 博客园 (cnblogs.com)

显然这些点在第一棵树上必然是一条链，所以我们用双指针维护这棵树上的一条链；对于这条链，判断其在第二棵树上是否满足条件的方法是：对于链上的每个节点，将其在第二棵树上以该点为根的子树全部染色（值+1），那么某个节点子树的最大值若是0，就可以加入链（并对子树染色），否则不能加入链（说明要么它的父节点已经染色，要么它有个子节点已染色）。对于第一颗树的操作可以用deque维护，第二棵树则可以用树链剖分+线段树维护最大值来解决。

搞了两天终于把这道树链剖分搞出来了qwq

代码

#include <bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 1e6 + 10;

struct line_tree
{
    struct node
    {
        int l, r, mx, add;
    } tr[N * 4];

    void pushup(int u)
    {
        tr[u].mx = max(tr[u << 1].mx, tr[u << 1 | 1].mx);
    }

    void build(int u, int l, int r)
    {
        tr[u] = {l, r, 0, 0};
        if(l == r)
            return ;
        int mid = (l + r) >> 1;
        build(u << 1, l, mid);
        build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }

    void pushdown(int u)
    {
        auto &root = tr[u],
              &lson = tr[u << 1],
               &rson = tr[u << 1 | 1];
        if(!root.add)
            return ;
        lson.add += root.add;
        lson.mx += root.add;
        rson.add += root.add;
        rson.mx += root.add;
        root.add = 0;
    }

    void modify(int u, int l, int r, int d)
    {
        if(tr[u].l >= l && tr[u].r <= r)
        {
            tr[u].add += d;
            tr[u].mx += d;
            return ;
        }
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) >> 1;
        if(l <= mid)
            modify(u << 1, l, r, d);
        if(r > mid)
            modify(u << 1 | 1, l, r, d);
        pushup(u);
    }

    int query(int u, int l, int r)
    {
        if(tr[u].l >= l && tr[u].r <= r)
            return tr[u].mx;
        pushdown(u);
        int mid = (tr[u].l + tr[u].r) >> 1;
        int ans = 0;
        if(l <= mid)
            ans = max(ans, query(u << 1, l, r));
        if(r > mid)
            ans = max(ans, query(u << 1 | 1, l, r));
        return ans;
    }
} line;

struct tree_chain2
{
    int head[N], nxt[N], top[N], es[N],
        wson[N], sz[N], dep[N], dfsn[N],
        par[N], tot, idx;

    void init()
    {
        idx = 0;
        tot = 0;
        memset(head, -1, sizeof head);
        memset(nxt, 0, sizeof nxt);
        memset(dep, 0, sizeof dep);
        memset(wson, 0, sizeof wson);
    }


    void addEdge(int u, int v)
    {
        es[++idx] = v;
        nxt[idx] = head[u];
        head[u] = idx;
    }

    void dfs1(int u, int fa)
    {
        sz[u] = 1;
        for(int i = head[u]; ~i; i = nxt[i])
        {
            int v = es[i];
            if(v == fa)
                continue;
            dep[v] = dep[u] + 1;
            par[v] = u;
            dfs1(v, u);
            sz[u] += sz[v];
            if(sz[wson[u]] < sz[v])
                wson[u] = v;
        }
    }

    void dfs2(int u, int tp)
    {
        dfsn[u] = ++tot;
        top[u] = tp;
        if(wson[u])
            dfs2(wson[u], tp);
        for(int i = head[u]; ~i; i = nxt[i])
        {
            int v = es[i];
            if(v == par[u] || v == wson[u])
                continue;
            dfs2(v, v);
        }
    }

    void modify(int x, int d) //x子树 += d
    {
        line.modify(1, dfsn[x], dfsn[x] + sz[x] - 1, d);
    }

    int query(int x) //查询子树的最大值
    {
        return line.query(1, dfsn[x], dfsn[x] + sz[x] - 1);
    }
} chain2;

struct tree_chain1
{
    int head[N], nxt[N], es[N], idx, ans;

    void init()
    {
        idx = 0;
        ans = 0;
        memset(head, -1, sizeof head);
    }

    void addEdge(int u, int v)
    {
        es[++idx] = v;
        nxt[idx] = head[u];
        head[u] = idx;
    }

    void dfs(int u, int fa, deque<int>& que)
    {
        ans = max(ans, (int)que.size());
        for(int i = head[u]; ~i; i = nxt[i])
        {
            deque<int> nxtque = que;
            stack<int> st;
            int v = es[i];
            if(v == fa)
                continue;
            nxtque.push_back(v);
            while(chain2.query(v) > 0)
            {
                chain2.modify(nxtque.front(), -1);
                st.push(nxtque.front());
                nxtque.pop_front();
            }
            chain2.modify(v, 1);
            dfs(v, u, nxtque);
            chain2.modify(v, -1);
            while(!st.empty())
            {
                chain2.modify(st.top(), 1);
                st.pop();
            }
        }
    }

} chain1;

int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        chain1.init();
        chain2.init();
        int n;
        cin >> n;
        for(int i = 0, u, v; i < n - 1; i++)
        {
            cin >> u >> v;
            chain1.addEdge(u, v);
            chain1.addEdge(v, u);
        }
        for(int i = 0, u, v; i < n - 1; i++)
        {
            cin >> u >> v;
            chain2.addEdge(u, v);
            chain2.addEdge(v, u);
        }
        chain2.dfs1(1, -1);
        chain2.dfs2(1, 1);
        line.build(1, 1, n);
        deque<int> que;
        que.push_back(1);
        chain2.modify(1, 1);
        chain1.dfs(1, -1, que);
        cout << chain1.ans << endl;
    }
    return 0;
}