CF 1529E. Trees of Tranquillity

CF 1529E. Trees of Tranquillity

题意：

有A1，A2两棵树，根是1，编号都是1~n，先制作图A3，如果两个点的x和y同时满足以下两个条件则连边，
1.在树A中x是y的祖先或者y是x的祖先
2.在树B中x和y谁都不是谁的祖先
求A3的最大的团集的大小
团：图G的一个完全子图
题目A1和A2的输入方式为：
a2，a3…an, ai是树的顶点i的父亲节点(1<= ai <i)

题解：

参考题解：
文章1
文章2
我们需要将题意转化：
满足最大团的点是什么样的？团要求任意两点都有连线，也就是最大团中所有点同时满足题目说的两个条件，因此这些点在A树上是一条的(没有分支)。在B树上体现为彼此不是父亲节点，我们引入dfs序，发现所有点的dfs序没有交集。
对于本题的输入还有一个特殊性质：ai <i，说明A树和B树从根节点出发的链，一定是一个单调递增的序列。针对B树的dfs序区间，就会有：序号较小的点的区间，要么包含序号较大的点的区间，要么与其不相交
对于两个点的dfs序区间，要么没有交集(不是父子关系)，要么存在包含(父子关系)，且左端点与右端点是对应的，父亲系节点的区间包含儿子节点的区间，因此对于一个互相包含的区间，我们要保留较小的(这样才能存下更多不相交的区间)，对应到树上，相当于 当一个点的儿孙可选时该点不选最优
现在我们从第一棵树的根开始dfs，每到一个点就往某数据结构中加入自己的区间：
1.如果被数据结构中原先的更大区间包含，那就删除大区间，加入小区间
2.如果包含了原有的至少一个小区间，那就不加
3.否则就加进去，答案+1
回溯时，数据结构要退回原来的状态

这个某数据结构可以用set，线段树等等
线段树具体实现过程：
先求树2的dfs序，然后对树1从根节点开始，查看当前点u的区间内是否有区间，如果没有直接插入，如果有，一定是比自己大的区间，所以删除原大区间，加入新区间。记录当前答案最大值，对u的儿子继续查找。回溯时逆向操作

代码：

线段树代码：

代码里有注释

#include<iostream>
#include<cstdio>
#include<string>
#include<ctime>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<stack>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<sstream>
#include<cassert>
#include<bitset>
#include<list>
#include<unordered_map>
#define lowbit(x) x&-x
using namespace std;
typedef long long LL;
typedef unsigned long long ull;
template<typename T>
inline void read(T &x)
{
	T f=1;x=0;
	char ch=getchar();
	while(0==isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(0!=isdigit(ch)) x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
	x*=f;
}
template<typename T>
inline void write(T x)
{
	if(x<0){x=~(x-1);putchar('-');}
    if(x>9)write(x/10);
    putchar(x%10+'0');
}
const int inf=0x3f3f3f3f;
const int N=1e6+100;
vector<int>a[N],b[N];
int L[N],R[N],dfn,sum,ans;
struct Node {
	int l,r,mmax,lazy;
}tree[N<<2];
void pushup(int k) {
	tree[k].mmax=max(tree[k<<1].mmax,tree[k<<1|1].mmax);
}
void pushdown(int k) {
	if(tree[k].lazy!=-1) {
		int lz=tree[k].lazy;
		tree[k].lazy=-1;
		tree[k<<1].mmax=tree[k<<1|1].mmax=lz;
		tree[k<<1].lazy=tree[k<<1|1].lazy=lz;
	}
}
void build(int k,int l,int r) {
	tree[k]={l,r,0,-1};
	if(l==r) {
		return;
	}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
}
void update(int k,int l,int r,int val) {
	if(tree[k].l>r||tree[k].r<l) {
		return;
	}
	if(tree[k].l>=l&&tree[k].r<=r) {
		tree[k].mmax=tree[k].lazy=val;
		return;
	}
	pushdown(k);
	update(k<<1,l,r,val);
	update(k<<1|1,l,r,val);
	pushup(k);
}
int query(int k,int l,int r) {
	if(tree[k].l>r||tree[k].r<l) {
		return 0;
	}
	if(tree[k].l>=l&&tree[k].r<=r) {
		return tree[k].mmax;
	}
	pushdown(k);
	return max(query(k<<1,l,r),query(k<<1|1,l,r));
}
void dfs1(int u) {//求树2的dfs序 
	L[u]=++dfn;
	for(auto v:b[u]) {
		dfs1(v);
	}
	R[u]=dfn;
}
void dfs2(int u) {
	int mmax=query(1,L[u],R[u]);
	if(!mmax) {//如果没有区间 
		update(1,L[u],R[u],u);
		sum++;
	} else {//存在区间，且区间一定比自己大 
		update(1,L[mmax],R[mmax],0);//删除原本区间 
		update(1,L[u],R[u],u);//加入新区间 
	}
	ans=max(ans,sum);
	for(auto v:a[u]) {
		dfs2(v);//对u的儿子节点继续查找 
	}
	//回溯操作 
	if(!mmax) {
		update(1,L[u],R[u],0);
		sum--;
	} else {
		update(1,L[u],R[u],0);
		update(1,L[mmax],R[mmax],mmax);
	}
}
int main()
{
	int w;
	cin>>w;
	while(w--) {
		int n;
		read(n);
		dfn=0;
		for(int i=1;i<=n;i++) {
			a[i].clear();
			b[i].clear();
		}
		for(int i=2;i<=n;i++) {
			int fa;
			read(fa);
			a[fa].push_back(i);
		}
		for(int i=2;i<=n;i++) {
			int fa;
			read(fa);
			b[fa].push_back(i);
		}
		dfn=ans=sum=0;
		build(1,1,n);
		dfs1(1);
		dfs2(1);
		cout<<ans<<endl;
	}
	return 0;
}

利用set实现

#include<set>
#include<cmath>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 300005
#define ENDL putchar('\n')
#define LL long long
#define DB double
#define lowbit(x) ((-x) & (x))
#define SI set<int>::iterator
LL read() {
	LL f = 1,x = 0;char s = getchar();
	while(s < '0' || s > '9') {if(s=='-')f = -f;s = getchar();}
	while(s >= '0' && s <= '9') {x=x*10+(s-'0');s = getchar();}
	return f * x;
}
int n,m,i,j,s,o,k;
vector<int> g0[MAXN];
int L[MAXN],R[MAXN],lR[MAXN],tim;//lR[]数组是为L找到唯一的R 
void dfs0(int x,int ff) {//求 树2的dfs序 
	L[x] = ++ tim;
	for(int i = 0;i < (int)g0[x].size();i ++) {
		if(g0[x][i] != ff) 
			dfs0(g0[x][i],x);
	}
	R[x] = tim; 
	lR[L[x]] = R[x];
	return ;
}
vector<int> g[MAXN];
int d[MAXN],dfn[MAXN],rr[MAXN],cnt,ans;
set<int> st;
void dfs(int x,int ff) {
	int ad = 0;
	if(st.empty()) st.insert(L[x]);//如果此时为空，直接插入 
	else {
		SI i = st.lower_bound(L[x]);//查找是否已经有区间 
		
		if(i != st.begin()) //发现有区间 
		{
			i --;
			if(lR[*i] >= R[x])//存在更大区间包含 
			{
				ad = *i;
				st.erase(ad);//删除大区间 
				st.insert(L[x]);//加入小区间 
			}
			else 
			{
				i ++;
				if(i == st.end() || *i > R[x]) //里面没有小区间，加入的区间不会相交 
					st.insert(L[x]);
			}
		}
		else if(i == st.end() || *i > R[x]) 
			st.insert(L[x]);//发现没区间 
	}
	ans = max(ans,(int)st.size());
	for(int i = 0;i < (int)g[x].size();i ++) {
		if(g[x][i] != ff) 
			dfs(g[x][i],x);
	}
	
	//回溯操作 
	if(st.find(L[x]) != st.end()) st.erase(L[x]);
	if(ad) st.insert(ad);
	return ;
}
int main() {
	int T = read();
	while(T --) {
		n = read();
		tim = 0; cnt = 0;
		st.clear();
		for(int i = 1;i <= n;i ++) {
			g0[i].clear();
			g[i].clear();
			lR[i] = 0;
		}
		for(int i = 2;i <= n;i ++) {
			s = read(); 
			g[s].push_back(i);
		}
		for(int i = 2;i <= n;i ++) {
			s = read(); 
			g0[s].push_back(i);
		}
		dfs0(1,0);
		ans = 0;
		dfs(1,0);
		printf("%d\n",ans);
	}
	return 0;
}