2021牛客多校7

F-xay loves trees（dfs序，区间修改）

题意：

给定两棵树（均是以 $1$ 为根节点），现在要选择一个最大点集 $S$ 。

该点集 $S$ 满足：

• 对于任意点对 $(u,v)$ ，在第一棵树上，其中一点是另外一点的祖先
• 对于任意点对 $(u,v)$ ，在第二棵树上，两点互不为祖先节点

思路：

题目的意思是，求一点集，在第一棵树上是 一条链 ，在第二棵树上是互不为祖先的孤点。

首先，求出第二棵树的 $dfs$ 序，然后， 每个节点的子树可以用一个区间表示。

然后，在树上维护一个可行的连续区间（链），一个节点是否加入链，要根据该点对应的 $dfs$ 序区间内是否有已经有点覆盖。如果没有，加入将该点加入链，并将该点对应的区间覆盖；如果没有，弹掉当前的链首节点，并修改对应的区间，直到当前节点可以加入到链中。（用线段树维护）

最后就是递归回溯，回溯时，要将当前节点区间修改消除，同时要将 为了加入该点而弹出的队首元素对应的区间 复原。

这样可以过，主要是因为数据太水了，来一个长链菊花图，递归回溯的时间开销会非常大。一开始是就是因为怕这种图，就没这样写，一直在写可持续化线段树来避免多次重复的恢复，然后。。。就 =^=，真就敢冲就敢给你过

先放一个上述暴力的做法，再去琢磨琢磨主席树的做法，还看到一个跑得飞快的 $set$ 做法。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;

const int N = 3e5 + 10;

struct set_tree {
    #define ls (rt << 1)
    #define rs ((rt << 1) | 1)
    ll tr[N << 2], tag[N << 2];
    void build (int l, int r, int rt) {
        if (l == r) {
            tr[rt] = 0;
            tag[rt] = 0;
            return;
        }
        int mid = (l + r) >> 1;
        build(l, mid, ls);
        build(mid + 1, r, rs);
        tr[rt] = tr[ls] + tr[rs];
        tag[rt] = 0;
    }
    void pushdown(int rt, int l, int r) {
        if (tag[rt]) {
            int mid = (l + r) >> 1;
            tr[ls] += 1LL * tag[rt] * (mid - l + 1);
            tr[rs] += 1LL * tag[rt] * (r - mid);
            tag[ls] += tag[rt];
            tag[rs] += tag[rt];
            tag[rt] = 0;
        }
    }
    ll query(int s, int t, int l, int r, int rt) {//s,t为查询区间，l,r是当前区间，rt为节点区间编号
        if (s <= l && r <= t) return 1LL * tr[rt];
        pushdown(rt, l, r);
        ll ans = 0;
        int mid = (l + r) >> 1;
        if (s <= mid) ans = 1LL * query(s, t, l, mid, ls);
        if (t > mid) ans += 1LL * query(s, t, mid + 1, r, rs);
        return ans;
    }
    void modify(int s, int t, int l, int r, int rt, int value) {  //区间加
        if (s <= l && r <= t) {
            tr[rt] += 1LL * value * (r - l + 1);
            tag[rt] += 1LL * value;
            return;
        }
        pushdown(rt, l, r);
        int mid = (l + r) >> 1;
        if (s <= mid) modify(s, t, l, mid, ls, value);
        if (t > mid) modify(s, t, mid + 1, r, rs, value);
        tr[rt] = tr[ls] + tr[rs];
    }
}T;

int n;

vector<int> g1[N];

int L[N], R[N], dep[N], dfsn[N], dd[N];
int dfs_cnt = 0;
vector<int> g2[N];
void dfs2(int u, int fa) { // 跑第二棵数树的dfs序，处理出每个节点的dfs序
    L[u] = ++dfs_cnt;
    dfsn[dfs_cnt] = u;
    dep[u] = dep[fa] + 1;
    for (int i = 0; i < (int)g2[u].size(); i++) {
        int v = g2[u][i];
        if (v == fa) continue;
        dfs2(v, u);
    }
    R[u] = dfs_cnt;
}

int ans;

int tp_cnt; // 可持续化线段树起点编号（不是节点编号）
int stk[N], top;


void dfs(int u, int fa, int st) {
    stk[++top] = u;
    int ns = st;
    int gg = T.query(L[u], R[u], 1, n, 1);
    if (gg == 0) {
        T.modify(L[u], R[u], 1, n, 1, 1);
    }
    else {
        while (ns + 1 < top) {
            ns++;
            int nod = stk[ns];
            T.modify(L[nod], R[nod], 1, n, 1, -1);
            int gg = T.query(L[u], R[u], 1, n, 1);
            if (gg == 0) {
                break;
            }
        }
        T.modify(L[u], R[u], 1, n, 1, 1);
    }
    ans = max(ans, (top - ns));
    for (int i = 0; i < (int)g1[u].size(); i++) {
        int v = g1[u][i];
        if (v == fa) continue;
        dfs(v, u, ns);
    }

    for (int x = st + 1; x <= ns; x++) {
        int nod = stk[x];
        T.modify(L[nod], R[nod], 1, n, 1, 1);
    }
    T.modify(L[stk[top]], R[stk[top]], 1, n, 1, -1);
    top--;
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        scanf("%d", &n);
        dfs_cnt = 0;
        for (int i = 0; i <= n; i++) {
            g1[i].clear(); g2[i].clear();
            dfsn[i] = 0;
            dep[i] = 0;
        }
        for (int i = 1; i < n; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            g1[u].push_back(v);
            g1[v].push_back(u);
        }
        for (int i = 1; i < n; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            g2[u].push_back(v);
            g2[v].push_back(u);
        }
        dfs2(1, 0);
        for (int i = 1; i <= n; i++) {
            dd[dfsn[i]] = i;
        }
        ans = 0; top = 0;
        T.build(1, n, 1);
        dfs(1, 0, 0);
        printf("%lld\n", ans);
    }
    return 0;
}