BZOJ[3772]精神污染 二维数点

BZOJ[3772]精神污染

本题就是求每条路径被多少条路径所覆盖（也可以求覆盖了多少条路径）。

我们对于一条路径，分析怎样的路径可以覆盖它。

假设路径A的两个端点为x，y，路径B的两个端点为a，b。($Dfn[a]<Dfn[b]andDfn[x]<Dfn[y]$)(注意这里的大小关系)

Dfn[i]表示i的dfs序，Lst[i]表示i子树内dfs序最大的点的dfs序。

如果这条路径A不是一条直链（也就是一个点是另一个点的祖先），那么如果另一条路径B要想覆盖它，就得满足B的两个端点分别在A的两个端点的子树中。

那么$Dfn[a]\in [Dfn[x],Lst[x]]andDfn[b]\in [Dfn[y],Lst[y]]$

如果这条路径是一条直链，那么。。（难以描述，先看图）

假设这条路径就是X–Y，那么另一条路径的一个端点会在A这个集合中，另一个端点会在B这个集合里，也就是不在S的子树里。（S是X到Y路径上Y的儿子）。

所以$Dfn[a]\in [1,Dfn[S]-1]andDfn[b]\in [Dfn[x],Lst[x]]$或者是$Dfn[a]\in [Dfn[x],Lst[x]]andDfn[b]\in [Lst[S]+1,n]$

因为这里要使$Dfn[a]<Dfn[b]$，故这个关系式才会长这样。

有了这两个关系式，本题就变成了一个二维数点问题，把每条路径看成（Dfn[x],Dfn[y])这样一个点，再用主席树什么的即可求解。(注意算的时候要把自己包含自己的情况删去)

AC代码：

#include<cstdio>
#include<algorithm>
#define M 100005
using namespace std;
struct E{
	int to,nx;
}edge[M<<1];
int tot,head[M];
void Addedge(int a,int b){//正向表 
	edge[++tot].to=b;
	edge[tot].nx=head[a];
	head[a]=tot;
}
int fa[M][20];
int Dfn[M],Lst[M],id_dfs;
struct Line{
	int x,y; 
	bool operator <(const Line &_)const{//先按x的DFS序排序 
		if(Dfn[x]!=Dfn[_.x])return Dfn[x]<Dfn[_.x];
		return Dfn[y]<Dfn[_.y];
	}
}T[M];
int dep[M];
int Up(int x,int y){//找x的第y个父亲 
	if(y<0)return 0;//如果x是y的祖先 
	for(int i=0;i<20;i++)if((1<<i)&y)x=fa[x][i];
	return x;
}
void dfs(int now){
	Dfn[now]=++id_dfs;
	for(int i=1;i<20;i++)fa[now][i]=fa[fa[now][i-1]][i-1];
	for(int i=head[now];i;i=edge[i].nx){
		int nxt=edge[i].to;
		if(fa[now][0]==nxt)continue;
		dep[nxt]=dep[now]+1;
		fa[nxt][0]=now;
		dfs(nxt);
	}
	Lst[now]=id_dfs;
}
long long gcd(long long a,long long b){
	if(!b)return a;
	return gcd(b,a%b);
}
struct Chair_tree{//一颗主席树 
	int Root[M];
	int sum[M*20],Lson[M*20],Rson[M*20],tot;
	void clear(){
		tot=0;
		Root[0]=sum[0]=Lson[0]=Rson[0]=0;
	}
	void Updata(int L,int R,int x,int oid,int &tid){
		tid=++tot;
		sum[tid]=sum[oid]+1;
		Lson[tid]=Lson[oid];
		Rson[tid]=Rson[oid];
		if(L==R)return;
		int mid=(L+R)>>1;
		if(x<=mid)Updata(L,mid,x,Lson[oid],Lson[tid]);
		else Updata(mid+1,R,x,Rson[oid],Rson[tid]);
	}
	int Query(int L,int R,int Lx,int Rx,int Lid,int Rid){
		if(!Lid&&!Rid)return 0;
		if(Lx<=L&&R<=Rx)return sum[Rid]-sum[Lid];
		int mid=(L+R)>>1;
		if(Rx<=mid)return Query(L,mid,Lx,Rx,Lson[Lid],Lson[Rid]);
		if(Lx>mid)return Query(mid+1,R,Lx,Rx,Rson[Lid],Rson[Rid]);
		return Query(L,mid,Lx,mid,Lson[Lid],Lson[Rid])+Query(mid+1,R,mid+1,Rx,Rson[Lid],Rson[Rid]);
	}
}CT;
int main(){
	CT.clear();
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=1;i<n;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		Addedge(a,b);
		Addedge(b,a);
	}
	long long ans=0,tot=1ll*m*(m-1)/2;
	dfs(1);
	for(int i=1;i<=m;i++){
		scanf("%d%d",&T[i].x,&T[i].y);
		if(Dfn[T[i].x]>Dfn[T[i].y])swap(T[i].x,T[i].y);//使x的DFS序大于y 
	}
	sort(T+1,T+m+1);//按x的DFS序排序 
	for(int i=1,id=1;i<=n;i++){//往主席树里加点 
		CT.Root[i]=CT.Root[i-1];
		while(id<=m&&Dfn[T[id].x]<=i){
			CT.Updata(1,n,Dfn[T[id].y],CT.Root[i],CT.Root[i]);
			id++;
		}
	}
	for(int i=1;i<=m;i++){
		int x=T[i].x,y=T[i].y;//如果这是一条链，那么dep[x]<dep[y] 
		int s=Up(y,dep[y]-dep[x]-1);//同题解里的图里的S 
		if(fa[s][0]==x){//如果这是一条链 
			ans+=CT.Query(1,n,Dfn[y],Lst[y],CT.Root[0],CT.Root[Dfn[s]-1]);
			ans+=CT.Query(1,n,Lst[s]+1,n,CT.Root[Dfn[y]-1],CT.Root[Lst[y]]);
			ans--;//减去自己包含自己的情况 
		}else ans+=CT.Query(1,n,Dfn[y],Lst[y],CT.Root[Dfn[x]-1],CT.Root[Lst[x]])-1;
	}
	long long g=gcd(ans,tot);
	printf("%lld/%lld\n",ans/g,tot/g);
	return 0;
}