LOJ#2339. 「WC2018」通道（边分治+虚树）

最新推荐文章于 2023-11-21 12:28:31 发布
最新推荐文章于 2023-11-21 12:28:31 发布
阅读量287 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 点分治 虚树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_35649707/article/details/82958902
该博客介绍了如何解决LOJ#2339的问题，重点在于利用边分治和虚树方法处理两棵树中的特定距离计算。通过挂点和调整树结构，将问题转化为求解直径，并讨论了在没有负权重情况下最长链的处理策略。最后，博主提到了使用归并排序建立虚树以实现O(nlogn)的时间复杂度解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

传送门

题解：
考虑两棵树怎么做，要求 max ⁡ d 1 ( x ) + d 1 ( y ) − 2 ∗ l c a 1 ( x , y ) + d i s 2 ( x , y ) \max d_1(x)+d_1(y)-2*lca_1(x,y)+dis_2(x,y) maxd1​(x)+d1​(y)−2∗lca1​(x,y)+dis2​(x,y)，把 x ′ x' x′挂在 x x x下面，长度为 d 1 ( x ) d_1(x) d1​(x)，然后就是 max ⁡ − 2 ∗ l c a 1 ( x , y ) + d i s 2 ( x , y ) \max -2*lca_1(x,y)+dis_2(x,y) max−2∗lca1​(x,y)+dis2​(x,y)。

相当于对于第一棵树求在第二棵树里面的直径。 因为没有负边权，我们直接记录最长链即可。

第三棵树采用边分治，对于每一层，相当于求 max ⁡ − 2 ∗ l c a 1 ( x , y ) + d i s 2 ( x , y ) + d 3 ( x ) + d 3 ( y ) \max -2*lca_1(x,y)+dis_2(x,y)+d_3(x)+d_3(y) max−2∗lca1​(x,y)+dis2​(x,y)+d3​(x)+d3​(y)。 用类似的方法，接在下方，然后相当于是第一棵树的每棵子树求一下两类点（边分治的两边）的直径。 A A A到 B B B集合的直径一定在 A A A集合最长链， B B B集合最长链的两端取得（在没有负权的情况下）。 然后就是一样的做法了。

用归并排序建虚树， O ( 1 ) O(1) O(1)lca，可以做到 O ( n log ⁡ n ) O(n \log n) O(nlogn)。

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair <int,LL> pii;

const int RLEN=1<<18|1;
inline char nc() {
	static char ibuf[RLEN],*ib,*ob;
	(ib==ob) && (ob=(ib=ibuf)+fread(ibuf,1,RLEN,stdin));
	return (ib==ob) ? -1 : *ib++;
}
inline LL rd() {
	char ch=nc(); LL i=0,f=1;
	while(!isdigit(ch)) {if(ch=='-')f=-1; ch=nc();}
	while(isdigit(ch)) {i=(i<<1)+(i<<3)+ch-'0'; ch=nc();}
	return i*f;
}

const int N=2e5+50, L=18;
int n,lg[N]; LL ans;
struct chain {
	int x,y; LL l;
	chain(int x=0,int y=0,LL l=0) : x(x),y(y),l(l) {}
	friend inline bool operator <(const chain &a,const chain &b) {return a.l<b.l || (a.l==b.l && a.x<b.x);}
};
struct T1 {
	int dfn[N],sze[N],pos[N],st[N][L+1],id[N];
	LL dep[N];  vector <pii> e[N];
	int tot,ind;
	inline void dfs(int x,int f) {
		id[dfn[x]=++ind]=x; sze[x]=1;
		st[pos[x]=++tot][0]=ind;
		for(auto v:e[x]) if(v.first^f) {
			dep[v.first]=dep[x]+v.second;
			dfs(v.first,x); st[++tot][0]=dfn[x];
			sze[x]+=sze[v.first];
		}
	}
	inline void init() {
		for(int i=1;i<n;i++) {
			int x=rd(), y=rd(); LL w=rd();
			e[x].push_back(pii(y,w));
			e[y].push_back(pii(x,w));
		} dfs(1,0);
		for(int i=1;i<=lg[tot];i++)
			for(int j=1;j+(1<<i)-1<=tot;++j)
				st[j][i]=min(st[j][i-1],st[j+(1<<(i-1))][i-1]);
	}
	inline int lca(int x,int y) {
		if(pos[x]>pos[y]) swap(x,y);
		int l=lg[pos[y]-pos[x]+1];
		return id[min(st[pos[x]][l],st[pos[y]-(1<<l)+1][l])]; 
	}
	inline bool in(int x,int y) {return dfn[y]<dfn[x]+sze[x] && dfn[y]>dfn[x];}
} t1,t2;
namespace t3 {
	int stx,sty,mxv,total; LL stl;
	int bl[N],sze[N],vs,tot; LL dep[N]; 
	vector <pii> e1[N];
	vector <pii> e2[N];
	vector <int> e[N];
	inline void dfs(int x,int f) {
		vector <pii> vec;
		for(auto v:e1[x]) if(v.first^f) 
			vec.push_back(v), dfs(v.first,x);
		for(int j=0;j<vec.size();++j) {
			e2[++tot].push_back(vec[j]);
			e2[vec[j].first].push_back(pii(tot,vec[j].second));
			int pre=j ? tot-1 : x;
			e2[pre].push_back(pii(tot,0));
			e2[tot].push_back(pii(pre,0));
		}
	}
	inline void init() {
		for(int i=1;i<n;i++) {
			int x=rd(), y=rd(); LL w=rd();
			e1[x].push_back(pii(y,w));
			e1[y].push_back(pii(x,w));
		} tot=n; dfs(1,0);
	}
	inline void calcG(int x,int f) {
		sze[x]=1; 
		for(auto v:e2[x]) if(v.first^f && bl[v.first]==bl[x]) {
			calcG(v.first,x); sze[x]+=sze[v.first];
			if(max(sze[v.first],total-sze[v.first])<=mxv) {
				mxv=max(sze[v.first],total-sze[v.first]); 
				stx=x; sty=v.first; stl=v.second;
			}
		} bl[x]=vs;
	} 
	int stk[N],id[N],top,ic;
	int fa[N],a[N],cnt,rt;
	chain mx[N][2];
	inline void build_vir(vector <int> &q) {
		cnt=top=0; 
		for(auto i:q) a[++cnt]=i;
		for(auto i:q) {
			if(!top) stk[++top]=rt=i;
			else {
				int l=t1.lca(i,stk[top]);
				while(t1.in(l,stk[top])) {
					if(top==1 || t1.in(stk[top-1],l)) fa[stk[top]]=l;
					--top;
				}
				if(l!=stk[top]) {
					if(!top) rt=l;
					a[++cnt]=l; 
					fa[l]=stk[top];
					stk[++top]=l;
				}
				fa[i]=stk[top];
				stk[++top]=i;
			}
		}
		for(int i=1;i<=cnt;i++) e[a[i]].clear();
		for(int i=1;i<=cnt;i++) if(a[i]!=rt) e[fa[a[i]]].push_back(a[i]);
	}
	inline LL ask_dis(int x,int y) {
		int l=t2.lca(x,y);
		return t2.dep[x]+t2.dep[y]-2*t2.dep[l]+t1.dep[x]+dep[x]+t1.dep[y]+dep[y];
	}
	inline void upt_ans(int i,int x,int y) {
		ans=max(ans,ask_dis(x,y)-2*t1.dep[i]);
	}
	inline chain merge(chain &a,chain &b) {
		chain c=chain(0,0,0);
		c=max(c,chain(a.x,b.x,ask_dis(a.x,b.x)));
		c=max(c,chain(a.x,b.y,ask_dis(a.x,b.y)));
		c=max(c,chain(a.y,b.x,ask_dis(a.y,b.x)));
		c=max(c,chain(a.y,b.y,ask_dis(a.y,b.y)));
		return max(a,max(b,c));
	}
	inline void merge(int x,int y) {
		for(int i=0;i<=1;i++) {
			upt_ans(x,mx[x][i].x,mx[y][i^1].x);
			upt_ans(x,mx[x][i].x,mx[y][i^1].y);
			upt_ans(x,mx[x][i].y,mx[y][i^1].x);
			upt_ans(x,mx[x][i].y,mx[y][i^1].y);
		}
		mx[x][0]=merge(mx[x][0],mx[y][0]);
		mx[x][1]=merge(mx[x][1],mx[y][1]);
	}
	inline void dfs_ans(int x,int f) {
		mx[x][0]=(id[x]&1) ? chain(0,0,0) : chain(x,x,0);
		mx[x][1]=(id[x]&1) ? chain(x,x,0) : chain(0,0,0);
		for(auto v:e[x]) {
			dfs_ans(v,x);
			merge(x,v);
		}
	}
	inline void dfs_pre(int x,int f) {
		for(auto v:e2[x]) if(v.first^f && id[v.first]==ic) {
			dep[v.first]=dep[x]+v.second; dfs_pre(v.first,x);
		}
	}
	inline vector <int> calc(int l,int r,LL mid,vector <int> &ql,vector <int> &qr) {
		vector <int> q;
		int hl=0, hr=0;
		while(hl<ql.size() && hr<qr.size()) q.push_back((t1.dfn[ql[hl]]<t1.dfn[qr[hr]]) ? ql[hl++] : qr[hr++]);
		while(hl<ql.size()) q.push_back(ql[hl++]); while(hr<qr.size()) q.push_back(qr[hr++]);
		vector <int> ct;
		for(auto i:q) if(i<=n) ct.push_back(i);
		build_vir(ct);
		++ic; for(auto i:ql) id[i]=ic;
		dep[l]=0; dfs_pre(l,r);
		++ic; for(auto i:qr) id[i]=ic;
		dep[r]=mid; dfs_pre(r,l);
		dfs_ans(rt,0);
		return q;
	}
	
	inline vector <int> solve(int x,int y,LL len) {
		vector <int> ql,qr;
		if(total-sze[y]>1) {
			++vs; total=mxv=total-sze[y];
			calcG(x,y); ql=solve(stx,sty,stl);
		} else ql.push_back(x);
		if(sze[y]>1) {
			++vs; total=mxv=sze[y];
			calcG(y,x); qr=solve(stx,sty,stl);
		} else qr.push_back(y);
		ql=calc(x,y,len,ql,qr);
		return ql;
	}
	inline void solve() {
		mxv=total=tot;
		calcG(1,0);
		solve(stx,sty,stl);
	}
}

int main() {
	n=rd(); lg[1]=0;
	for(int i=2;i<=n*2;i++) lg[i]=lg[i>>1]+1; 
	t1.init(); t2.init(); 
	t3::init();
	t3::solve();
	cout<<ans<<'\n';
}
「WC2018」通道（边分治套虚树）
Freopen的博客
01-16 431
题目 先考虑两棵树怎么做。 我们在第二棵树的每一个点uuu上再挂一个点u′u'u′，他们的距离为第一棵树上的depudep_udepu​。 那么在第二棵树上的两点u′,v′u',v'u′,v′的距离就是两棵树上距离总和-u,vu,vu,v在第一棵树上的lcalcalca的深度×2\times 2×2 考虑枚举这个lcalcalca，那么答案就应该是lcalcalca的两个不同子树S1,S2S1,S...
【代码超详解】LOJ #132. 树状数组 3 ：区间修改，区间查询
COFACTOR
02-07 687
一、题目描述 样例 样例输入 5 10 2 6 6 1 1 2 1 4 1 2 5 10 2 1 3 2 2 3 1 2 2 8 1 2 3 7 1 4 4 10 2 1 2 1 4 5 6 2 3 4 样例输出 15 34 32 33 50 二、算法分析说明与代码编写指导 如果不了解树状数组，建议先阅读之前的题解： https://blog.csdn.net/COFACTOR/arti...
[WC2018]通道
weixin_34262482的博客
03-29 221
[WC2018]通道 爽到爽到爽到爽到爽到爽到爽到爽到爽到爽到爽到爽到爽到一遍AC 但是题目太神主要还是为了锻炼码力 3棵树，考虑层层处理，互相考虑 第一棵 边分治。儿子少。虚边权值为0。 统计在第一棵树上跨过中心边的点对 找到d1，到中心边距离。两个点第一个距离已经可以计算 左部为L，右部为R。 下面以这个为基础统计 第二棵 第二棵第三棵的结构无法掌握。要具体一些。 ...
@loj - 2339@ 「WC2018」通道
weixin_30357231的博客
08-04 127
目录 @desription@ @solution@ @accepted code@ @details@ @desription@ 11328 年，C 国的科学家们研发了一种高速传送通道，可以在很短的时间内把居民从通道的一端送往另一端，这些通道都是双向的。...
WC2018 通道
weixin_30493401的博客
03-21 215
好久以前开的坑． 到今天才填上． 首先考虑队第一颗树边分，然后分成两个集合\(L,R\)，在第二棵树上建出虚树，在每个路径\(lca\)处统计答案，维护点集的直径只有正权很好维护． #include <bits/stdc++.h> using namespace std; typedef long long ll; typedef pair<int,int> p; typ...
LOJ #143. 质数判定 题解
bifanwen的博客
07-19 381
博客园同步 原题链接 简要题意： 给定 TTT 个数 nnn，判素数。 T≤105,n≤1018T \leq 10^5 , n \leq 10^{18}T≤105,n≤1018. 可能你判一个都有困难是不是 ⋯⋯\cdots \cdots⋯⋯. 二次探测定理 若 x2≡1(modp),x<px^2 \equiv 1 \pmod p , x < px2≡1(modp),x<p，则 x=1x= 1x=1 或 x=p−1x = p-1x=p−1. 简单证明： x2≡1(modp)x^2 \eq
LOJ #10134. 「一本通 4.4 练习 1」Dis
最新发布
qq_17807067的博客
11-21 244
LOJ #10134. 「一本通 4.4 练习 1」Dis，几乎LCA模板题。还有一道升级版LOJ #2491. 「BJOI2018」求和
LOJ#10022. 埃及分数【搜索+剪枝】
ETwinner的博客
03-13 335
题目描述 https://loj.ac/problem/10022 这是一个因gcd打错而耽误的题。 这个题要枚举的是有多少个分数，迭代加深搜索！！ #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; using namespace std; typedef long long ll; ll a,b,c[2...
【LOJ】#6374. 「SDWC2018 Day1」网格 【容斥套容斥】
执子之手,与子偕老
01-30 1955
【LOJ】#6374. 「SDWC2018 Day1」网格 这是一道计数好题，不难，但是需要对二项式反演的理论非常熟悉 包含三层容斥，关于3个限制：不能在原地，x,y的步数限制，非法向量 处理方法都是枚举至少超出限制 所有容斥都是二项式反演：从至少k转移给恰好0，应该乘C(k,0) * (-1)^k，相当于没有乘组合数 注意容斥的时候每一步之间是要组合和排列的 一定要把题目限制看清楚： 如果这...
[树分治 虚树] LOJ#2339. 「WC2018」通道
CE玩家
02-10 741
考场打了树分治套链分治拿了64分… 大概就是把第三棵树树分治，（用左儿子右兄弟的方法重构），然后在第二棵树建立虚树，然后树形DP，每个点记录子树的点在第一棵树中距离最大的两个点，然后合并 #include &lt;cstdio&gt; #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;vector&gt; #...
[WC2018 通道]
aijiu8213的博客
08-02 206
题目大意：给定三棵树，求点对\((x,y)\)使得\(d1(x,y) + d2(x,y) + d3(x,y)\)最大。 Solution： 前两棵树我们可以用构造虚树的方式来求\(d1(x,y) + d2(x,y)\)。 记点对\((x,y)\)在第一棵树上的LCA是fa，那么\(dis_all(x,y) = dep1(x) + dep1(y) - dep1(fa) + dis2(x,y...
【BZOJ5152】【UOJ347】【WC2018】通道
cz_xuyixuan的博客
06-07 540
【题目链接】 BZOJ UOJ 【思路要点】 首先，我们来考虑只有两棵树的情况。 我们枚举两个点在第一棵树上的LCA，那么这两个点应该位于LCA的不同的子树中，点对\((x,y)\)的价值应当为\(deptha_x+deptha_y-2*deptha_{Lca}+distb(x,y)\)。 对于第二棵树上的每一个点\(x\)，新建\(x'\)与其相连，边权为\(deptha_x\...
【WC2018】通道【边分治】【虚树】【树的直径】
Lstdo的博客
12-27 225
现在的心态，只不过是为了不留遗憾，趁着退役前把想做的题做了。
「WC2018」通道-边分治+虚树+DP
DSL_HN_2002的博客
12-12 404
Description 给定三棵树，最大化dista(x,y)+distb(x,y)+distc(x,y)dista(x,y)+distb(x,y)+distc(x,y)dista(x,y)+distb(x,y)+distc(x,y)。 n≤100000n \leq 100000n≤100000 Solution 先考虑两棵树怎么做。 点对(x,y)(x,y)(x,y)的贡献为depax+depa...
「WC2018」通道
weixin_30379911的博客
09-15 195
「WC2018」通道 解题思路： 问题要最大化三棵树上的路径和，码码码就完事了。 第一棵树上边分，对于每一个边分中心 \(mid\)，钦点边左边的联通块为黑色，右边联通块为白色，令 \[ f1(x)=\begin{cases} dis1(x,mid) & color(x)=black \\ dis1(x,mid) +weight(mid) & color(x) = whi...
【学习笔记】[WC2018]通道
cqbzlydd的博客
12-31 697
码农题，难以评价。
【WC2018】通道（边分治，虚树，动态规划）
weixin_30687051的博客
12-29 144
【WC2018】通道（边分治，虚树，动态规划） 题面 UOJ 洛谷 题解 既然是三棵树，那么显然就是找点什么东西来套个三层。 一棵树怎么做？入门dp。 两棵树？假设在第一棵树中的深度为\(dep\)。在第一棵树中枚举\(LCA\)，因为两点之间距离可以转化为两点深度和减去两倍\(LCA\)的深度，而已知当前的\(LCA\)是谁了。那么在第二棵树上的每个节点\(u\)下挂一个\(u'\)，边权为\(...
LOJ6354 & 洛谷4366：[Code+#4]最短路——题解
05-17
这道题需要使用 Dijkstra 算法来解决。 Dijkstra 算法是一种贪心算法，用于解决没有负权边的单源最短路径问题。算法的基本思想是：从源点开始，每次选择当前最短路径的节点，并更新其周围节点的距离。 具体步骤如下： 1. 初始化距离数组 dist，将源点到自己的距离设为 0，其他点到源点的距离设为无穷大。 2. 创建一个集合 visited，用于存储已经确定最短路径的节点。 3. 将源点加入 visited 集合中。 4. 对于源点周围的每个节点，更新它们到源点的距离。如果距离更短，则更新 dist 数组。 5. 从 dist 数组中选择距离最短的节点，将其加入 visited 集合中。 6. 重复第 4 步和第 5 步，直到所有节点都被加入 visited 集合中。 7. dist 数组中的值即为源点到每个节点的最短距离。 注意事项： 1. Dijkstra 算法只适用于没有负权边的图。 2. Dijkstra 算法不能处理有向无环图中的负权边。 下面是 Python 代码实现：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值