2019南昌邀请赛网络赛 J. Distance on the tree

最新推荐文章于 2023-10-13 18:16:31 发布

原创最新推荐文章于 2023-10-13 18:16:31 发布 · 544 阅读

0 ·

CC 4.0 BY-SA版权

线段树同时被 3 个专栏收录

28 篇文章

订阅专栏

离线

5 篇文章

订阅专栏

树链剖分

4 篇文章

订阅专栏

本文介绍了一种使用树链剖分数据结构解决离线询问问题的方法，具体为求解给定图中满足特定条件的边的数量。通过在树上每条边中间添加一个点并赋予其边的权值，将问题转化为求点的权值和。文章详细描述了算法流程，包括对边和询问进行排序、构建树链剖分和线段树，以及处理询问的具体步骤。

最基本的离线询问，然后跑数据结构。

此题因为是求边的数量，但是我的树链剖分模板是给点加值和求和求最大值，于是我们在树上每条边中间加一个点，那么这个点的权值就是边的权值。

对边排序，对询问排序，k从小到大处理询问，每次把当前询问小的边加到线段树的点里面，然后求路径上有多少个满足条件的边就是树链剖分后线段树idx[u]到idx[v]的权值和了。

队友状态不好，丢给我这个只写过一道模板题树链剖分的人写，1A了还是很开心的。(主要是题太裸了。。

#include<bits/stdc++.h>
#define maxl 200010
#define inf 2000000001 
using namespace std;

int n,nn,q,cnt=0,nodecnt=0,num=0;
int a[maxl],dep[maxl],tot[maxl],son[maxl],top[maxl],fa[maxl],ehead[maxl];
int idx[maxl],dy[maxl],ans[maxl];
struct ed
{
	int to,nxt;
}e[maxl<<1];
struct node
{
	int l,r,sum;
}tree[maxl<<2];
struct qu
{
	int u,v,w,id;
}que[maxl],edg[maxl<<1];
char ch[maxl];

inline void adde(int u,int v)
{
	e[++cnt].to=v;e[cnt].nxt=ehead[u];ehead[u]=cnt;
}

void dfs1(int u,int f)
{
	int v;
	dep[u]=dep[f]+1;fa[u]=f;tot[u]=1;
	for(int i=ehead[u];i;i=e[i].nxt)
	{
		v=e[i].to;
		if(v==f) continue;
		dfs1(v,u);
		tot[u]+=tot[v];
		if(tot[v]>tot[son[u]])
			son[u]=v;
	}
}

void dfs2(int u,int topf)
{
	int v;
	idx[u]=++nodecnt;dy[nodecnt]=u;
	top[u]=topf;
	if(!son[u]) return;
	dfs2(son[u],topf);
	for(int i=ehead[u];i;i=e[i].nxt)
	{
		v=e[i].to;
		if(idx[v]) continue;
		dfs2(v,v);
	}
}

void build(int k,int l,int r)
{
	tree[k].l=l;tree[k].r=r;
	if(l==r)
	{
		tree[k].sum=0;
		return;
	}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
	tree[k].sum=tree[k<<1].sum+tree[k<<1|1].sum;
}

inline bool cmp(const qu &x,const qu &y)
{
	return x.w<y.w;
}

inline void prework()
{
	scanf("%d%d",&n,&q);
	int u,v,w;num=n;
	nn=n;
	for(int i=1;i<=n-1;i++)
	{
		scanf("%d%d%d",&u,&v,&w);
		num++;edg[i]=qu{u,v,w,num};
		adde(u,num);adde(num,v);
		adde(v,num);adde(num,u);
	}
	for(int i=1;i<=q;i++)
	{
		scanf("%d%d%d",&que[i].u,&que[i].v,&que[i].w);
		que[i].id=i;;
	}
	sort(edg+1,edg+1+n-1,cmp);
	sort(que+1,que+1+q,cmp);
	n=num;
	dfs1(1,0);
	dfs2(1,1);
	build(1,1,n);
}

void add(int k,int l)
{
	if(tree[k].l==tree[k].r)
	{
		tree[k].sum++;
		return;
	}
	int mid=(tree[k].l+tree[k].r)>>1;
	if(l<=mid)
		add(k<<1,l);
	else
		add(k<<1|1,l);
	tree[k].sum=tree[k<<1].sum+tree[k<<1|1].sum;
}

int getsum(int k,int l,int r)
{
	if(tree[k].l==l && tree[k].r==r)
		return tree[k].sum;
	int mid=(tree[k].l+tree[k].r)>>1;
	if(l>mid)
		return getsum(k<<1|1,l,r);
	else
	if(r<=mid)
		return getsum(k<<1,l,r);
	else
		return getsum(k<<1,l,mid)+getsum(k<<1|1,mid+1,r);
}

inline int gettreesum(int x,int y)
{
	int ans=0;
	while(top[x]!=top[y])
	{
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		ans+=getsum(1,idx[top[x]],idx[x]);
		x=fa[top[x]];
	}
	if(dep[x]>dep[y]) swap(x,y);
	ans+=getsum(1,idx[x],idx[y]);
	return ans;
	//printf("%d\n",ans);
}

inline void mainwork()
{
	int edind=0;
	for(int i=1;i<=q;i++)
	{
		while(edind<nn-1 && edg[edind+1].w<=que[i].w)
			++edind,add(1,idx[edg[edind].id]);
		ans[que[i].id]=gettreesum(que[i].u,que[i].v);
	}
}

inline void print()
{
	for(int i=1;i<=q;i++)
		printf("%d\n",ans[i]);
}

int main()
{
	prework();
	mainwork();
	print();
	return 0;
}