线段树 ---- 线段树维护线段相加+滑动变长窗口 2021牛客多校第7场 F xay loves trees

题目大意：

给你两个大小相同的树但是形状不一定一样
叫你选出最大的子集，满足下面两个条件

1. 在第一颗树上是一条链
2. 在第二颗树上任意两个点都不是祖先关系

---

解题思路：

1. 首先我们现在第二颗树上面把每个点的dfs序处理处理，那么就变成在第一颗树上面找到最长的一条链，链上点的dfs序区间都不相交，祖先关系的点会存在下图关系
   
2. 那么最开始我们想的是二分最大长度然后每次都去维护固定长度的链，每次区间修改(区间覆盖)，$O(1)$查询，但是是$O(nlo{g}^{2}n)$过不来
3. 优化：假如我们dfs到某个点我们假如我们发现长度为$len$是可以那么我们就可以保存这个长度去维护滑动窗口类似！因为答案肯定不会比$len$还短，维护短的没意义，那么这个长度就是单调递增的，那么这样就没二分了！！
4. 时间复杂度$O(nlogn)$

---

AC代码：

线段树区间加，维护区间最大值！！
最大值为1就是不相交！！
重复覆盖就是2！！

#include <bits/stdc++.h>

#define endl '\n'
#define IOS std::ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define mp make_pair
#define seteps(N) fixed << setprecision(N) 
typedef long long ll;

template<typename T> void read(T &x) {
   x = 0;char ch = getchar();ll f = 1;
   while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
   while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) {
   read(first);
   read(args...);
}

using namespace std;
/*-----------------------------------------------------------------*/

ll gcd(ll a, ll b) {return b ? gcd(b, a % b) : a;}
#define INF 0x3f3f3f3f

const int N = 6e5 + 10;
const double eps = 1e-5;
typedef pair<int, int> PII;
int mx[N << 1];
int lazy[N << 1];
int dfn;

struct edge {
    int nt, ne;
};

int head[N];
edge ed[N];
int si;
PII seg[N];
int que[N];
int st, et;
int n;

void init(int n) {
    dfn = 0;
    for(int i = 1; i <= n; i++) head[i] = 0;
    si = 0;
}

void add(int u, int v) {
    ed[++si] = edge{v, head[u]};
    head[u] = si;
}

void pushdown(int rt) {
    if(lazy[rt]) {
        lazy[rt << 1] += lazy[rt];
        mx[rt << 1] += lazy[rt];
        lazy[rt << 1 | 1] += lazy[rt];
        mx[rt << 1 | 1] += lazy[rt];
        lazy[rt] = 0;
    }
}

void build(int l, int r, int rt) {
    if(l == r) {
        lazy[rt] = mx[rt] = 0;
        return ;
    }
    int mid = (l + r) / 2;
    build(l, mid, rt << 1);
    build(mid + 1, r, rt << 1 | 1);
    lazy[rt] = mx[rt] = 0;
}

void upd(int l, int r, int L, int R, int val, int rt) {
    if(l >= L && r <= R) {
        mx[rt] += val;
        lazy[rt] += val;
        return ;
    }
    int mid = (l + r) / 2;
    pushdown(rt);
    if(mid >= L) upd(l, mid, L, R, val, rt << 1);
    if(mid < R) upd(mid + 1, r, L, R, val, rt << 1 | 1);
    mx[rt] = max(mx[rt << 1], mx[rt << 1 | 1]);
}


void dfs1(int p, int fa) {
    dfn++;
    seg[p].first = dfn;
    for(int e = head[p]; e; e = ed[e].ne) {
        int np = ed[e].nt;
        if(np == fa) continue;
        dfs1(np, p);
    }
    seg[p].second = dfn;
}
int ans = 0;
void dfs2(int p, int fa) {
    int pp = -1;
    que[et++] = p;
    upd(1, n, seg[p].first, seg[p].second, 1, 1);
    if(mx[1] == 1) {
        ans = max(ans, et - st);//出现了更长的链更新答案
    } else {
        if(et - st > ans) {//否则维护长度为ans的队列
            pp = que[st++];
            upd(1, n, seg[pp].first, seg[pp].second, -1, 1);
        }
    }
    for(int e = head[p]; e; e = ed[e].ne) {
        int np = ed[e].nt;
        if(np == fa) continue;
        dfs2(np, p);
    } 
    if(pp > 0) {
        upd(1, n, seg[pp].first, seg[pp].second, 1, 1);
        que[--st] = pp;
    }
    upd(1, n, seg[p].first, seg[p].second, -1, 1);
    et--;
    return ;
}

vector<PII> G1;

int main() {
    int t;
    read(t);
    while(t--) {
        st = et = 0;
        G1.clear();
        read(n);
        init(n);
        build(1, n, 1);
        for(int i = 1; i < n; i++) {
            int u, v;
            read(u,v);
            G1.push_back({u, v});
        }
        for(int i = 1; i < n; i++) {
            int u, v;
            read(u,v);
            add(u, v);
            add(v, u);
        }
        dfs1(1, 0);
        init(n);
        for(auto &e : G1) {
            add(e.first, e.second);
            add(e.second, e.first);
        }
        ans = 0;
        dfs2(1, 0);
        printf("%d\n",ans);
    }
}